{% raw %}
戚锦锦秀
院(系)航天学院控制科学与工程系 专 自动化
1110410427 指导教师 杨旭东
2015629
计((论文)
目::深深度度学学习习在在图图像像识识别别中中的的应应用
自动动化
1110410427
戚锦锦秀
指导导教教师 杨旭旭东
答辩辩日日期 2015629
哈尔滨工业大学本科毕业设计(论文)
摘 要
点,
表,型、
术,
别、果。
理,MNISTCIFAR
练,利GPUCPUMNIST数据98.9%别正率,
CIFAR-10据集得了62%正确率。在本中,我还讨包括
维在内的多个神经网络设计技巧以及实验中发现的一些现象。
置信MCMC
GPU计算
- I -
哈尔滨工业大学本科毕业设计(论文)
Abstract
Deep learning as a branch of machine learning which is represented by a full con-
nected neural network named Deep Belief Networks as well as a local connected network
named Convolutional Neural Networks has drawn lots of attention in the field of artificial
intelligence. Multiple technologies like probabilistic graphical models and Markov Chain
Monte Carlo methods have integrated into deep learning nowadays and they help deep
learning make a great breakthrough in many AI tasks such as speech and image recogni-
tion by training models based on large-scale data. This paper focus on the principles of
Deep Belief Networks and Convolution Neural Network s, and we trained some models
on the MNIST and CIFAR-10 dataset using DBNs or CNNs. As a result, we achieved
98.9% recognition accuracy on MNIST dataset and 62% recognition accuracy on CIFAR-
10 dataset with the help of GPU&CPU-based heterogeneous computing. A number of
phenomena found in our experiments and tricks of designing the neural networks, includ-
ing dimensionality reduction, will also be discussed in this paper.
Keywords: deep learning, restricted boltzmann machines, deep belief networks, convo-
lutional neural networks, Markov chain Monte Carlo, GPU computation
- II -
哈尔滨工业大学本科毕业设计(论文)
目 录
摘 要............................................................................................. I
ABSTRACT ...................................................................................... II
1 绪论 .................................................................................... 1
1.1 课题来源及研究的目的和意义 .......................................................... 1
1.2 国内外在该方向的研究现状及分析.................................................... 3
1.2.1 神经网络与深度学习的发展状况................................................. 3
1.2.2 感知器时期............................................................................... 3
1.2.3 反向传播时期 ........................................................................... 5
1.2.4 深度学习时期 ........................................................................... 5
1.3 深度学习在人工智能上的应用 .......................................................... 6
1.3.1 语音识别 .................................................................................. 6
1.3.2 图像识别 .................................................................................. 6
1.3.3 自然语言处理 ........................................................................... 7
2 控制论与机器学习 .................................................................. 8
2.1 白盒模型与经典控制论 .................................................................... 8
2.2 灰盒模型与系统辨识........................................................................ 9
2.3 黑盒模型与统计机器学习................................................................. 9
2.4 本章小结 ........................................................................................ 11
3 受限玻尔兹曼机 ..................................................................... 12
3.1 伊辛模型 ........................................................................................ 12
3.2 玻尔兹曼机..................................................................................... 13
3.3 受限玻尔兹曼机 .............................................................................. 14
3.4 本章小结 ........................................................................................ 19
4 马尔可夫链蒙特卡罗方法 ......................................................... 20
4.1 蒙塔卡罗方法核心思想 .................................................................... 20
4.2 舍弃采样 ........................................................................................ 21
4.3 重要性采样..................................................................................... 25
4.4 马尔可夫链..................................................................................... 27
4.5 Metropolis-Hastings算法 ................................................................... 30
- III -
哈尔滨工业大学本科毕业设计(论文)
4.6 Gibbs采样....................................................................................... 33
4.7 对比离差 ........................................................................................ 35
4.8 本章小结 ........................................................................................ 36
5 深度置信网络 ........................................................................ 37
5.1 神经网络组成及表达能力................................................................. 37
5.1.1 神经元 ..................................................................................... 37
5.1.2 逻辑表达 .................................................................................. 39
5.2 神经网络的前馈 .............................................................................. 40
5.2.1 神经激活 .................................................................................. 41
5.3 分类器............................................................................................ 45
5.3.1 平方误差分类器 ........................................................................ 45
5.3.2 softmax分类器........................................................................... 46
5.4 神经网络的反馈 .............................................................................. 48
5.4.1 分类器参数校正 ........................................................................ 49
5.4.2 误差传播 .................................................................................. 51
5.5 深度置信网络.................................................................................. 53
5.6 本章小结 ........................................................................................ 56
6 卷积神经网络 ........................................................................ 57
6.1 卷积神经网络综述........................................................................... 57
6.2 卷积神经网络的前馈........................................................................ 59
6.2.1 卷积......................................................................................... 59
6.2.2 采样......................................................................................... 62
6.2.3 分类器 ..................................................................................... 63
6.3 卷积神经网络的反馈........................................................................ 63
6.3.1 分类器误差传播 ........................................................................ 63
6.3.2 采样层误差传播 ........................................................................ 64
6.3.3 卷积层误差传播 ........................................................................ 64
6.4 本章小结 ........................................................................................ 65
7 神经网络的设计技巧 ............................................................... 66
7.1 数据预处理..................................................................................... 66
7.1.1 降维......................................................................................... 67
7.1.2 扩容......................................................................................... 74
- IV -
哈尔滨工业大学本科毕业设计(论文)
7.2 训练技巧 ........................................................................................ 75
7.2.1 学习率 ..................................................................................... 75
7.2.2 动量项 ..................................................................................... 77
7.2.3 权衰减 ..................................................................................... 78
7.3 编码技巧 ........................................................................................ 79
7.3.1 面向对象技术 ........................................................................... 79
7.3.2 梯度校验 .................................................................................. 80
7.4 本章小结 ........................................................................................ 81
8 GPU计算 .............................................................................. 82
8.1 GPU体系结构.................................................................................. 82
8.2 CUDA ............................................................................................ 85
8.3 Cudamat.......................................................................................... 87
8.4 Gnumpy .......................................................................................... 87
8.5 PyCUDA......................................................................................... 88
8.6 Cae .............................................................................................. 89
8.7 本章小结 ........................................................................................ 90
9 实验现象及讨论 ..................................................................... 91
9.1 数据集简介..................................................................................... 91
9.1.1 MNIST ..................................................................................... 91
9.1.2 CIFAR-10 ................................................................................. 92
9.2 深度置信网络在MNIST数据集上的性能............................................. 93
9.3 卷积神经网络在MNIST数据集上的性能............................................. 96
9.4 卷积神经网络在CIFAR-10数据集上的性能......................................... 98
9.5 使用Cae实现的CIFAR-10数据集训练 ............................................... 101
9.6 本章小结 ........................................................................................ 103
结 论.............................................................................................104
参考文献..........................................................................................105
原创性声明.......................................................................................109
致 谢.............................................................................................110
附录 A 深度置信网络源代码 ...............................................................111
附录 B 卷积神经网络源代码................................................................127
- V -
哈尔滨工业大学本科毕业设计(论文)
1 绪论
1.1 课题来源及研究的目的和意义
畴,学,
模式别源自于工程学,尽这两者源于不同的背景,但这者可以认为是
个领同描
[1]
。自生以来,们一索一
器能实现智能 期的一部研究人员试图事物的机理出发,寻模式背后
的规律,比在自语言处理域,最初人们从析语法语开始,企图让机
理解然语言,并实现一些似于翻译类的工作,但失了,一个重要的
因是自然言的规则错综杂,要摸其运作机理哪以目前的学科水平看也
几乎是难以实现的。
里,理,
但实结果都不尽人意,机建模这条路看起来像是条死胡同。到了上世
九十代,统计机学习开始为主流,经过二多年的高发展,目前基于
计的建模法成为了主流,而统计机学习取得的成远大于上世纪六十到到
九十年代取得的成果,当然这也不排除计算机运算能力的影响。
相比机理模,统计机器学的出点是从数出发,建立个可以刻
已有据的概率分布,如果机理建模作是牛顿力学,那么计学习就相当
学。上,法,
早在上世七十年代统计习就已经开始出现。统计器学习使我们不再要研
究模背后的运作机理,并通过它可实现通用学习。如果一个事物背后
一个数决定了它的性,那么我们不需要研究这个数究竟是什么式,只
要有够多的数据,通过统计法,选取恰当的型,我们便可以一定程度
拟合出这函数,尽管我们拟合出的数在大多数情下都不等价于事物本质
函数,但如果它能在可允许的误差范围内正常工作,这就足够了。
统计器学方法的出现,使工作点转为寻合适模型上,事实上
是统习其风险
[2]
。也说,我们何寻
个合的模型,使测试误差小化 由于型的选取决于设计的意愿,我
们既以选择一简单的模型,比如线性数,也可以选择个复杂的数,比
如高次多项式函数,但是实际问题中,大多数情况下,如果使用简单的线性函数,
- 1 -
哈尔滨工业大学本科毕业设计(论文)
数据低维空间中是可分的,为了使据变得线性可分,我可以将数据由
维空间映射到高维空间中,但这种方案引入了庞大的运算以至于计算机难以计算,
“维难”线加,大。
又或者,我们一始就不使用线性函而使用较为复的函数比如高斯函实现
非线分割,但由于我们不道数据的布形式,也难以将实问题中的高维
据可化,所以除非我们有于数据分的先验知识,否则并知道我们选取
这个复杂的函数是否是合理的。
为了决维灾难,我们可以使用核数,在低维间中直接算高维空
返回结果,避开高维空间运算,这种方法被称之为方法,比如上世
十年提出支撑机(kernel-SVM)就一种使了核法的器。而
如果了避免复杂函的选取问题,我可以使用神经络。神经网络基于一
假说—–智能源自于单一的算法,在神经网络中,我们只需选取激活函数,即所谓
的“单一的算法”,然后训练网络的连接权值,从而跳过函数选取步骤。
于神网络表达方面,理论上,柯格洛Kolmogorov)证
明了要给足够多的经元、合适激活函数及恰当的值,任何从输入
到输的连续映射函都可以用层神经网络实现。如从傅里叶理论看,则
相当于任何连续函数都可以用足够多的谐波来逼近
[3]
关, 关, 度,
HastadGoldmann1991年提出了以下定理
[4]
定理 1.1 为了计算一个函数 f
k
F
k,N
,深度为k 1的单调加权门限电路所需的规模
至少为2
cN
,其中常数c > 0N > N
0
切,1.1
语,则为深度为k的神经网络所能表达的函数,深度为k 1的神经网络为了达到
同样的效果至少需要引入指数级规模的节点。
倘若大脑学的角度考,我们已知道,哺乳物的大脑一个深度
构,它可以输入的模式在个层次上行抽象再表达,而每层次对应着皮
的不区域。以大脑在视觉统上的工机理为例,其工作过依次经过如下
个步骤边界检测、基本外形建立、逐渐地完善更为详尽外形
[5]
在定1.1以及大脑科学的启发下,我们对深度神经网络充满信心,因此神经
络研员花十年深度网络究,然2006年之
[6, 7]
我们都难找到一个较好算法来训练深度神网络,其原因一方面是深神经
网络局部最优解繁多,导致深度神经网络比浅层神经网络更容易陷入局部最小值,
- 2 -
哈尔滨工业大学本科毕业设计(论文)
另一方面则是受计算机运算能力的限制
[8]
2006Hinton法,
逐层
[9]
,成现了深度网络,深度络又
络、
[10]
法,习。
前,类、归、类、
[11]
理、索、
中,
法。
1.2 国内外在该方向的研究现状及分析
20155月,Nature60题,
回顾了过的研究历程与今的研究热点,其中深度习作为一个热点被以介
[12]
。目前深度学习在国内外都受到广泛关注,新的深度学习算法源源不断地被
提出,在不久的将来,深度学习将会取得更多的成功。
1.2.1 神经网络与深度学习的发展状况
数十年来,神经网络研究人员在神经科学上付出了巨大心血,其研究之深入,
范围广,内容之繁杂是别机器学习法所难以企及的。我今天看到的深
学习是神经计算科中的冰山角,在它之下,是几十年探积累起来的失
经验,这些型中不乏观点颖却无法作的模型。这么多年研究人员试图
神经网络理论化,然而到目前为止这项工作依然没有实现。
1.2.2 感知器时期
久,1800络,
1943年心理学家Warren McCulloch与数理逻辑学Walter Pitts在总结前人关于神经
化,·
使
[13]
案。
现,联接主义学者迫切地期待建立一个可用的神经网络数学模型,在这个环境中,
Warren McCullochWalter Pitts作的下,Frank Rosenblatt了第
个神经元模型—-感知器
[14]
,这标志着神经网络进入第一次浪潮。
- 3 -
哈尔滨工业大学本科毕业设计(论文)
1-1 感知器模型
如图1-1 所示,在感知器中,含有d个输入和1个输出,其中非线性激活函数为
阶跃函数,即
y =
1 θ
T
x b 0
0 其他
(1-1)
b项,值。释,
中,x激,θ
T
x加。
b时,活,y = 1应,
y = 0
伴随知器一同提出的还括感知器练算法,其方法鉴了生理学中
于反馈方面的思想,通过引入奖励与惩罚的概念,当某个训练样本被正确分类时,
参数维持不变,若该样本被错误分类,则通过惩罚项对对参数进行更新
[2]
得益非线性的活函数,感知器络可以实逻辑功能及非线性分类
务。例如,在输入维度为2的感知器网络中,若网络参数θ = [2, 2]
T
,偏置b = 3
时,门。与、
或、非三种本逻门,而这三者又以构成所的逻辑函数,因我们有理
相信,恰当感知网络可以现逻辑功能。事上,六十年代感器网络的
出,也确实解决了一些简单的人工智能任务。
神经络第次浪只持了大约十左右,其原因,一面,六十年
是电计算机刚刚兴的年代,人们更地关注于计算机,导感知器网络得
到重视,另方面,限于子管及早晶体管的艺,耗费大量的源来建立
个感器网络似乎也太现实。此外,人们一没有找到一种较好地训练多
感知网络的算法,导致了大神经网络者对其失信心,因此,在六十年
末期,神经网络的研究进入第一个低谷。
- 4 -
哈尔滨工业大学本科毕业设计(论文)
1.2.3 反向传播时期
潮,1986Hinton
RemelhartWilliams传播
[15]
首次别任使
用反传播训练神经网络,得了较好效果。此外,大规模集电路的发
以及sigmoid等新的激活函数的应用也很大程度程度上推动了神经网络的发展。
反向播算通过链式导,将偏导从高层传回低层,使多层感知
网络中可使用简单的梯下降方法进行训练,尤其在三层感知器网络效果
显著。后,感知器络也改名神经络,尽管如此,神网络是人为主
地对经元建模,其本质与物的神经统是没有太大系的,例如神经具有
的,
性。
期,出,使Hebb
Hopfield网络
[16]
、将Hopfield络随机化后的玻尔兹曼
[17]
、具备模式变换不变
的卷
[3]
,此外,新的快速播、共轭被应
神经网络中。
九十代人开始尝试立深度神网络,但随网络度的加大,局部
优解多,在参数没有被恰地初始化情况下,使用反向传算法进行简单
值,络。
在硬件方面,九年代计算机的计算力仍不足以满深度神经网络中大模的
运算。此外,同时期被提出的SVM法可以在较少运算的前提下实现高性能的
类,因此,在九十年代中期,神经网络进入第二次低谷。
1.2.4 深度学习时期
深度神经网络的僵局一直持续到2006年,HintonOsindero深度置信网络中
使用一种监督的逐层贪预训练受限玻尔兹机,使得权值被初始化到个合
适的位置,随后对整个网使用全局的反向传播进行有监督微调,在MNIST
数字务上了已
[6]
,随后,受限曼机上又
展出了稀疏编码与自动编码机等方法。深度置信网络是一种无监督学习,对应的,
LeCun人提卷积了在下的
[18, 19]
,成
第一个真正意义上的深度结构。
2006 来,
[20, 21]
Google Facebook
Microsoft 工、 学、
- 5 -
哈尔滨工业大学本科毕业设计(论文)
源到度学的相关研中,麻省理工大2013年将度学习评十大突破
术的榜首
[22]
。由于深度学习需要训练样本容量足够大,而近年来大数据时代的
来,人们难处理模如此庞的数据,所以某程度上,深度学与大数据
相辅相成的。
2012 后, 中,
2013划,“深院”
院,2014长。
2014年开发Mariana平台将致力于研究深度学习在语音识别、图像识别和广告
荐上用。2015将开JIMI”机项目,将深习应
人工客服上。
1.3 深度学习在人工智能上的应用
深度习在人工能领域正取得重大展,利用这套技解决了历史遗
大量题,目前已用到学、商业、政上。除在传的声、图、文
域深度学习掀起巨浪外,深度学习逐步开始渗入到生物学等其他领域。
1.3.1 语音识别
传统的语音识别一般使用混合高斯模型(GMM)或隐马尔可夫模型HMM
[3]
单, 率。 Microsoft2009
Hinton作,2011
的应用,该用已投入WindowsPhone的语音识别“小娜”中。Google、百
也开语音别框的改革,Google使45的神网络,而百使用9
经网
[22]
。使用深度神经网络实现的语音识别在错误率上要比传统方法的错误率
相对少20% 30%左右。
1.3.2 图像识别
声、图、中,
著。MNIST中,使98%
右,使SVM98.6%率,使
99.79%率。ImageNet1000中,1000别,
展,72%85%89%93%段,
- 6 -
哈尔滨工业大学本科毕业设计(论文)
20151月,由微软亚太研究院实现的最好效果96.06%
[23]
。在SVHN街景门牌
中,Google1197.84%率,
这个系统已经帮助Google从街景中分析出全球近1 亿个门牌号。
1.3.3 自然语言处理
Microsoft2012天津使用深练的统,其
翻译传统方法为流畅。然而,目在自然语处理领域,深度习取得的
果并有显著超越传方法。相比于图识别以及语音别,自然语言处理一
难点于上下文,尽管深度习被认为一种特征学习,但这特征学习似乎
没有现可以联系上文的功能。自然言处理在近期广受关注,深度学习研
人员认为下一个突破口将会出现在自然语言处理上。
- 7 -
哈尔滨工业大学本科毕业设计(论文)
2 控制论与机器学习
质,
[24]
是,
这里的熵不是指热力学的热力熵或信息论的信息熵,而应理解为熵原始
定义,对混乱的量。既然是量,便需要个准则,正测量个物体的
度需一把刻度尺,但不同的度尺将得不同的测结果,同理,对混乱的
同定义,也将得到同的制效果。例如,在度控系统中,让度保持在
个较的温度或较低温度均是制熵增的行为,因为者对熵的定义同。对
于孤系统,熵总朝着增加方向移动,但也例外,此时系统须是非孤
的,能够收到外界的制,比如机体具有熵减趋势,因为DNA是有序的(尽
我们目前仍无法完全理解它),其中起到控制作用的外力是自然选择。控制论所要
做的,便是引入外力作用,即反馈,或者说控制环节,以之降低系统的混乱程度,
得到我们的期望输出。
2.1 白盒模型与经典控制论
经典制论中,为实现对一系统控制,我们往需要先系统的结
开始析,利用牛力学、电磁原理、热力等物理原对系统特建立微分
程,将其转为复的传递函后,再利用根轨或频域分设计控制节。如
2.1 示的RLC中,我们u
i
(t)入,u
o
(t)出,
我们的信个系结构,要抑乱就u
0
(t)
们的期望输出迈进。
2-1 简单的RCL网络
由于这个系统的结构是已知的,整个系统对于我们而言相当一个白盒。为此,
我们可以很容易地根据基尔霍夫回路电压定律建立方程
u
L
(t) + u
R
(t) + u
o
(t) = u
i
(t) (2-1)
- 8 -
哈尔滨工业大学本科毕业设计(论文)
进一步利用电感特性、电容特性、欧姆定律,式(2-1)可以进一步推导为
LC
d
2
u
o
(t)
dt
2
+ RC
du
o
(t)
dt
+ u
o
(t) = u
i
(t) (2-2)
此时,输入出的分方程已立,下一步便是典控制论内容,我们并不
算继展开细说。这个例子中,我可以看出,白盒型对整个统是了如
掌的,是可以对其建模的。此时,“利用已有信息抑制系统的熵增”相当于,对系
统建立传递函数(利用已有信息),设计控制环节使我们能得到期望输出(抑制熵
增)
2.2 灰盒模型与系统辨识
牛顿生的工作自然科学贡献是无衡量的,但牛顿活的时代忽视
一些要的西统计概念。在牛力学中,有个前提,系统的状是可
的,此,析。而,
物理测量从来都不精确的,我们对界的观察也总片面而不确定的,世
对我们而言是未知的,我们无法完全确定事物的运作机理。例如图2.1 中的电阻R
R=50 法,(如
话)物是确,言,阻50
的。50念,50
统计结果。延伸到整个系统,图2.1 的网络也变得不确定,RLC均是不精确
值,此时系统变为一个灰盒模型。所谓灰盒模型,即系统的一部分内容是未知的,
一部容是的的,如这里,尽管RLC的精是未的,但
依然可以知道其数值的大致范围。
若我推广步,RLC范围也不道,如计该
的控制环便是系统辨识要研究的内容。系统辨识域中的一个重要的题是
如何解析一个含有未知数的系统结构,如果我们以获取系统的输入出样
本,利用这些样本,配合上含有未知参数的系统结构方程,采取恰当的拟合方法,
如最二乘以及极大然等,最后可以取未知参数的似解,使得这个灰盒
型的灰色褪去(但不会褪为白盒模型),进一步便可设计系统的控制环节。
2.3 黑盒模型与统计机器学习
白盒模型与灰盒模型的讨论均是基于一个前提我们知道系统整体模型框架,
只是些参数有可能未知的。但这个提在实际生活往往是不成立的,很
- 9 -
哈尔滨工业大学本科毕业设计(论文)
时候,我们但不道系统的数,甚至连系统模型也知甚少,此时的系
盒,构。如,100
为垃邮件,假设这个行为以用一个数来描述,即这个决背后存在一个
理(或者说数),通过它,我们输入100 符,函数的输出诉我们这邮件
是否为垃圾邮件,那么我们便可以通过这个函数来描述这个系统。可以肯定的值,
这个数在邮件完全分(即不存在一可能是或可能是垃圾邮件的况)的
的,的,
面。但这个方法并不现实,假使所有的汉字只有2000个,那么100的中文邮件将
2000
100
种可能,要穷举是不可能的。另一种做法是寻求语法结构,先对这100
进行词,再进行义分析,这个过也可以描为一个函映射过程设函
f (x)词,g(x)析,y出,么系
y = g[ f (x)]。这种想法早在二十年前就被抛弃,因为自然语言含有强烈的上下文
气息。如在“冬天穿多穿多少,夏天穿多少穿少”这例子中,同
句“能穿多穿多少”在同的上下中含有不的意义。尽管我人认为这
上下背后也必然存一个因果系,但这种因果关系在是太难寻找了,所
这种方法也不是一个可行的方案。
统计器学的做法是,假定个模型(这模型系统本质模型关联
不大),利用大量样本训练假设的模型,最后将训练完毕的模型作为本质模型的逼
近。与之前论的统辨识相比,两在训练阶是类似的,均是用样本进
参数定,不同点于,系统辨识是练带有强先验的模型(比由具体物
原理推导出的传递函数)的参数,而统计学习训练的是假设模型(比如高斯模型、
隐式马尔可夫模型、神经网络、支持向量机等)的参数。
回到圾邮件分的例子中,统计器学习的种解决方是利用朴素贝
类,中,型。
d典,{ 买、销、···}时,
封邮件都可以用一个d维列向量表示。例如,某封邮件在字典中的元素只包含“购
买”,而其他的元素均不包含,那么这封邮件便可以表示为
x = [1, 0, 0, ··· , 0]
T
(2-3)
本,
p(x
i
|y = 1)中,y签,件,
y = 1,反之y = 0x
i
代表字典中的i个元素,例如,我们的字典中,x
1
= “购
买”。建后,我式,计
- 10 -
哈尔滨工业大学本科毕业设计(论文)
时的概率分布
p(x|y = 1) = p(x
1
, x
2
, ·, x
d
|y = 1)
= p(x
1
|y = 1)p(x
2
|y = 1) ··· p(x
d
|y = 1)
(2-4)
显然,式(2-4)在数学上只有在x
i
均独立时才成立,而本质上,x
i
并不是独立的(因
为存在上下文),这里本应使用全概率公式,而我们之所以假设x
i
独立的原因是这
样做以降低模的复杂度。以说,在统计学中,假设模型与质模型的
联往往不大。
型训后(即p(x
i
|y = 1)于一到的件,我们使
用贝叶斯公式即可计算该邮件是垃圾邮件的概率
p(y = 1|x) =
p(x|y = 1)p(y = 1)
p(x)
=
d
i=1
p(x
i
|y = 1)
d
i=1
p(x
i
|y = 1) +
d
i=1
p(x
i
|y = 0)
(2-5)
验,斯,析,
这并符合自然言的原理。实际中,尽管这模型并不本质模型,但逼
效果足以让人接受,能工作得很好,因此被很多邮件厂商所采用。
2-2 机器学习系统框图
义,Tom.Mitchell
TPTP
E而自我完善,那么我们称这个计算机程序从经验E中学习
[25]
。如果将这段话转
化成系统框图,则如图2-2 所示。
2.4 本章小结
精确只存于数学中,现实界充了不确定性,难以寻找物背后的
理。统学习绕过套机理,根设计的意愿,假一个模型,用这个模
逼近事物的机理,相当于把世界看成一个黑盒,并不打算去探索黑盒的内部结构,
而是仿造一个黑盒来模拟其工作原理。
- 11 -
哈尔滨工业大学本科毕业设计(论文)
3 受限玻尔兹曼机
统计学习并不在乎事物的本质是什么,我们更关心的是数据的分布是怎样的,
为了述数据的布,我们往引入各种样的模型画这种分布,比如,贝
布,等。
对于一个任务,采用不同模型得到结果是不一样的,机学习与模式识
的一不同在于,机器习更注重计,模式识更注于模型。例如,对
同一任务,机器学习学者能会假设多个模型,再根据模选择理论选取
个最优的型,而模式识别学者更倾于先大致分析个任务更适合使用个模
型,选取后细优这个模型。尽管者有一定差异性,但很多面两者是
通的,如神经网络。神经网络不依于具体的务,也就是说,语音识别
以用经网络处理,图像识也可以用经网络处理,之所以这样做的一个
因是,神经络的部对于我而言是透的,如果我们只重结果,希望有
个模型可在给定一个输的时候输出一个决结果,不需要关心这个结是怎
么得的,那么神网络是一很好的选择。神网络的种众多,一个分支
机,型,后,
在这网络的基础上发展出一受限玻尔兹曼机,通这些网络,都可以建
数据的概率分布描述。
3.1 伊辛模型
模型Ising model统计质相
[16]
,是
相互耦合的自阵列。比如铁这种物中,当温度降到个程度,微观原
的自会表现出一定倾向性,从而在观上产生磁矩,而当度升高到一定
度时,其自旋就变得随机。
N 子, 子,
+11s 态, s
状态,那么我们定义该伊辛模型处于状态s下的能量函数为
[16]
E(s; W, H) =
1
2
N
i, j =1
w
i j
s
i
s
j
+
j
Hs
j
(3-1)
式中,w
i j
代表原子i和原子 j之间的耦合,如果i j是相邻的,那么w
i j
= C,否
w
i j
= 0C > 0的,的。
- 12 -
哈尔滨工业大学本科毕业设计(论文)
H场,E(s; w, H)量函数,化的数,们也
Lyapunov函数。如果将这个能量函数推广到HW不是常数的情况,即
[16]
E(s; W, H) =
1
2
N
i, j =1
w
i j
s
i
s
j
+
j
h
j
s
j
(3-2)
此时们将得到个物理学称之为“自玻璃”的模型,这也是经网络中
Hopfield网络”
3.2 玻尔兹曼机
中,统,
(比布)
i的概率为p
i
,那么当系统与外界达到热平衡时,其概率分布为
p
i
=
1
Z
T
e
E
i
/T
(3-3)
式中,T 代表系统所处的温度,E
i
代表系统处在i状态下的能量,Z
T
是在T 温度下为
了使得概满足柯尔莫果夫第二公理的归一常数。这个分布也称之为则分
布或吉布斯分布。
在机器学习中,我们往往自定义一个能量函数,然后通过正则分布建立模型,
通过这种于能量的模型对数据进行分析。所以正分布可以看做是机学习
与统计物理间的桥梁。
果将(3-2)的作场去掉,并改成矩形式,得到尔兹机中
能量函数
E(s; W) =
1
2
s
T
W s (3-4)
事实上,在机器学习中我们并不关心常数T ,则玻尔兹曼分布为
p
i
=
1
Z
e
E
i
=
1
Z
exp
1
2
s
T
W s
(3-5)
象,n征,
n维特征,因此我们往往引入隐含特征的概念,假设对于一个对象,我们能观察
v特征,么我v点来这些征,又假们自隐含
h个,那么我h个节来代表这特征。比如3-1 了含4个可节点
2个隐含节点的玻尔兹曼网络。
由图3-1 可见,在玻尔兹曼机中,可见节点与可见节点之间、隐含节点与隐含
节点间是可以有连的,因此这是一反馈网络。层内节点连接可以大大
- 13 -
哈尔滨工业大学本科毕业设计(论文)
a) 未拓扑前的玻尔兹曼机 b) 拓扑后的玻尔兹曼机
3-1 玻尔兹曼机网络构型
增强络的表达能力,但是大大地增了网络的训练度,因此玻尔兹曼机
没有非常成功地解决人工智能的任务。
3.3 受限玻尔兹曼机
在受限玻尔兹曼机Restrict Boltzmann MachineRBM)中,我们取消层间连
接,从而出发后经过若干次“移动”也无法回到原点,因此RBM可以认为是
个有向无环图。其网络结构图3-2 所示。
3-2 RBM 网络构型
为了方便往后的讨论,我们约定网络参数的数学符号如下
W
n
h
×n
v
=
w
1,1
w
1,2
··· w
1,n
v
w
2,1
w
2,2
··· w
2,n
v
.
.
.
.
.
.
.
.
.
.
.
.
w
n
h
,1
w
n
h
,2
··· w
n
h
,n
v
v =
v
1
v
2
.
.
.
v
n
v
h =
h
1
h
2
.
.
.
h
n
h
b
v
=
b
v
1
b
v
2
.
.
.
b
v
n
v
b
h
=
b
h
1
b
h
2
.
.
.
b
h
n
h
(3-6)
中,W
n
h
×n
v
数,w
i j
i j
值,W
n
h
×n
v
ih
i
值, j
- 14 -
哈尔滨工业大学本科毕业设计(论文)
v
j
的所有连接的权值。v代表可见节点的状态,h代表隐含节点的状态,b
v
代表隐
含层到可见层的偏置,b
h
代表可见层到隐含层的偏置。
RBM中,我们定义其Lyapunov函数如下
[26]
E(v, h) =
n
v
i=1
b
v
i
v
i
n
h
j=1
b
h
j
h
j
n
v
i=1
n
h
j=1
h
j
w
j,i
v
i
(3-7)
若将(3-7)写成矩阵形式,则为
E(v, h) = b
T
v
v b
T
h
h h
T
Wv (3-8)
由正则分布的定义(3-3),我们可以得到vh的联合分布为
p(v, h) =
1
Z
e
E(v,h)
(3-9)
其中配分函数Z
Z =
v,h
e
E(v,h)
(3-10)
由于实际中我们往往只能观察到可见节点,因此对联合分布(3-9)边缘化得
p(v) =
h
1
Z
e
E(v,h)
=
1
Z
h
e
E(v,h)
(3-11)
这个p(v)总可以写成如下形式
p(v) =
e
F(v)
Z
(3-12)
式中,我们称F(v)为自由能函数
[4]
,由式(3-11)(3-12),我们不难推出F(v)
F(v) = ln
h
e
E(v,h)
(3-13)
为了续我们往的讨论,我们不证明地引关于受限尔兹曼机的一
定理
定理 3.1 RBM中,在给定可见元状态时,隐含元的激活条件独立;反之,在给
定隐含元状态时,可见元的激活条件独立
此外,我们还需引入一些记号
h
k
= (h
1
, h
2
, ··· , h
k1
, h
k+1
, ··· , h
n
h
)
T
(3-14)
α(k) = b
h
k
+
n
v
i=1
w
k,i
v
i
(3-15)
β(v, h
k
) =
n
v
i=1
b
v
i
v
i
+
n
h
j=1
jk
b
h
j
h
j
+
n
v
i=1
n
h
j=1
jk
h
j
w
j,i
v
i
(3-16)
- 15 -
哈尔滨工业大学本科毕业设计(论文)
h
k
代表除k外的所有隐含元状态,β(v, h
k
)代表除h
k
外所有节点构成的能量函数。
因此,总的能量函数(3-7)可以写为
E(v, h) = β(v, h
k
) h
k
α(k) (3-17)
数,时,h
k
其激活概率为
P(h
k
= 1|v) (3-18)
由定理3.1,式(3-18)等价于
P(h
k
= 1|h
k
, v) =
P(h
k
= 1, h
k
, v)
P(h
k
, v)
=
P(h
k
= 1, h
k
, v)
P(h
k
= 0, h
k
, v) + P(h
k
= 1, h
k
, v)
=
1
1 + exp
E(h
k
= 0, h
k
, v) + E(h
k
= 1, h
k
, v)
=
1
1 + exp

β(v, h
k
) + α(k) · 0
+
β(v, h
k
) α(k) · 1

=
1
1 + e
α(k)
= sigmoid
α(k)
(3-19)
因此,给定可见层状态时,隐含元k的激活概率为
P(h
k
= 1|v) = sigmoid(b
h
k
+
n
v
j=1
w
k, j
v
j
) (3-20)
同理可推导在给定隐含层状态时,可见元k的激活概率为
P(v
k
= 1|h) = sigmoid(b
v
k
+
n
k
i=1
w
i,k
h
i
) (3-21)
由定理3.1的独立性可知
P(h|v) =
n
k
j=1
P(h
j
|v) (3-22)
P(v|h) =
n
v
i=1
P(v
i
|h) (3-23)
RBM中,Wb
v
b
h
使
分布。为了方便起见,我们记θ = (W, b
v
, b
h
),注意,这并不是矩阵合并,而是将所
有的参数用θ来代替。
假定我们有一个训练集S
- 16 -
哈尔滨工业大学本科毕业设计(论文)
S = {v
(1)
, v
(2)
, ···v
(i)
, ··· , v
(n
s
)
} (3-24)
其中n
s
为训练样本数,v
(i)
为第i个样本且
v
(i)
= [v
(i)
1
, v
(i)
2
, ··· , v
(i)
n
v
]
T
(3-25)
由于样本是独立的,因此似然函数为
L(θ) =
n
s
i=1
P(v
(i)
) (3-26)
对应的对数似然为
(θ) = ln
n
s
i=1
P(v
(i)
) =
n
s
i=1
ln P(v
(i)
) (3-27)
对于个训集,我们要化参数,使得似然大化,设我们使梯度
升方法,则针对某个样本ˆv ,参数的更新规则为
θ = θ + η
ln L
ˆv
∂θ
(3-28)
其中
ln L
ˆv
= ln P (ˆv)
= ln
1
Z
h
e
E(ˆv,h)
= ln
h
e
E(ˆv,h)
ln Z
(3-29)
从而
ln L
ˆv
∂θ
=
∂θ
ln
h
e
E(ˆv,h)
∂θ
ln Z
(3-30)
由式(3-10)、式(3-11)、式(3-12),得
ln L
ˆv
∂θ
=
∂θ
F(ˆv) +
1
Z
v
e
F(v)
∂θ
F(v)
=
∂θ
F(ˆv) +
v
p(v)
∂θ
F(v)
(3-31)
通过自由能函数F(v)对参数θ求偏导,我们有
∂θ
F(v) =
h
e
E(v,h)
·
E(v,h)
∂θ
h
e
E(v,h)
=
h
e
E(v,h)
/Z
h
e
E(v,h)
/Z
·
E(v, h)
∂θ
=
h
p(v, h)
p(v)
·
E(v, h)
∂θ
(3-32)
从而,式(3-31)等价于
- 17 -
哈尔滨工业大学本科毕业设计(论文)
ln L
ˆv
∂θ
=
h
p(ˆv, h)
p(ˆv)
·
E(ˆv, h)
∂θ
+
v
p(v)
h
p(v, h)
p(v)
·
E(v, h)
∂θ
=
h
p(h|ˆv) ·
E(ˆv, h)
∂θ
+
v,h
p(v, h)
E(v, h)
∂θ
= E
p(h|ˆv)
E(ˆv, h)
∂θ
+ E
p(v,h)
E(v, h)
∂θ
(3-33)
式中,E
p(h|ˆv)
p(h|ˆv)分布下的期望,E
p(v,h)
p(v, h)分布下的期望。
通过式(3-33),我们就可以计算相对于某个样ˆv对数似然梯度。(3-33)
项是的,因为p(h|v)式,(3-20)
(3-22)θ = (W, b
v
, b
h
)Wb
v
b
h
推导梯度公式。
h
p(h|v)
E(v, h)
w
i j
=
h
n
h
k=1
p(h
k
|v)h
i
v
j
=
h
i
h
i
p(h
i
|v)p(h
i
|v)h
i
v
j
=
h
i
p(h
i
|v)h
i
v
j
h
i
p(h
i
|v)
=
h
i
p(h
i
|v)h
i
v
j
=
h
i
p(h
i
|v)v
j
(3-34)
h
p(h|v)
E(v, h)
b
h
i
=
h
n
h
k=1
p(h
k
|v)h
i
=
h
i
h
i
p(h
i
|v)p(h
i
|v)h
i
=
h
i
p(h
i
|v)h
i
h
i
p(h
i
|v)
=
h
i
p(h
i
|v)h
i
=
h
i
p(h
i
|v)
(3-35)
h
p(h|v)
E(v, h)
b
vi
=
h
p(h|v)v
i
= v
i
(3-36)
- 18 -
哈尔滨工业大学本科毕业设计(论文)
(3-34)(3-35)(3-36)(3-33)
项, 算, Z
O(2
n
v
+n
h
)复杂度的项,因此我们需要使用马尔可夫链蒙特卡罗方法MCMC
行处理。
3.4 本章小结
本章中,我们伊辛模型发,引玻尔兹曼机,进一推广到受波尔
曼机。在受玻尔曼机中,我们建了对数据述的概率布即正则布,随
后,我们推导出限玻尔兹曼机中由见节点激活隐节点以及由隐含节激活
可见点所使用的公式,时,如果整网络的参是确的,那么,利用这
网络以刻画数据的征。但由于未经练的网络参数未知的,我们需要使
样本求取参数的近值,求取的方法们使用极大似然,为使用梯度下降
数,导,使度。
但由于这梯度有一项不易求取,我们需要利用马可夫链蒙特卡罗方来处
理,但章没有详讨论,因此,章节并不一个立的章节,虑到马尔
夫链蒙特卡罗方法所蕴含的内容较多,所以我们将其独立成为一章。
- 19 -
哈尔滨工业大学本科毕业设计(论文)
4 马尔可夫链蒙特卡罗方法
特卡被评20世纪法”之一,20世纪50法被
出后的几十年里已被学术界与工业界广泛应用。这套方法最初源自Stan Ulam
纸牌戏的考,他试图52张卡的组可能,在尝穷举败后,他意
解。后,
他找到·诺依曼,两人共同完善了蒙特卡罗方法的一些理论,比如重要性采样和
舍弃样。由于蒙卡罗方法一整套解方案,算法众多,其理贡献不能
仅归功于这两人,还应包括提出MH算法的MetroplisHasting、将蒙特卡罗方法应
用到中子扩散问题的Fermi
[27]
20世纪80年代,蒙特卡罗方法被引入机器视觉与
人工能领域,同时,在之上加入尔可夫链成一套新理论体系。这套
论常于贝叶斯断的归一化、边缘化与望问题,概率论配分函数题,最
优化问题以及机器学习中的模型选择问题。
4.1 蒙塔卡罗方法核心思想
蒙特罗方法的个应用是算一个分下某个函数的望,现在假设我
要计算一个积分
I
f
=
+
−∞
(2x
2
+ x + 1)
1
2π
exp
1
2
x
2
dx (4-1)
为了简化,我们记
f (x) = 2x
2
+ x + 1 (4-2)
p(x) =
1
2π
exp
1
2
x
2
(4-3)
那么,式(4-1)可以简写为
I
f
=
+
−∞
f (x) · p(x)dx (4-4)
由于p(x)好是一个标准高斯分布,倘若我们能从p(x)采样得到N独立
分布(i.i.d)样本{x
i
}
N
i=1
,则积分I
f
可以近似为
[27]
I
f
ˆ
I
f
=
1
N
N
i=1
f (x
i
) (4-5)
此时,若N ,根据大数定律,可知
- 20 -
哈尔滨工业大学本科毕业设计(论文)
I
f
= lim
N→∞
ˆ
I
f
= lim
N→∞
1
N
N
i=1
f (x
i
) (4-6)
若从学期的角上来释上问题,那么(4-1)以理
们现在有一个函数 f (x ) = 2x
2
+ x + 1其自变量x 符合标准高斯分布,x N(0, 1)
f (x)N(0, 1)望,N(0, 1)
N个独的样{x
i
}
N
i=1
,将些样代入 f (x)得到N数值{f (x
i
)}
N
i=1
,对
函数值求和取平均后得到的结果即为期I
f
的近似
ˆ
I
f
。显然,其近似程度与N
关,N越大,采样的样本越多,近似的程度也便越高。
(4-1)殊,先,p(x)布,使
以利用一些很成熟的方法来从N(0, 1)中采样出N个样本,但如果p(x)是一个高斯
分布,也不一个匀分布、伽马分等一些我常见的概分布,它只是一
布, 次,(4-1)式,
而实生活中的概率布往往是维的,那么高维情况该如何推广 来的
几个小节我们将致力于解决以上几个问题。
4.2 舍弃采样
提到题,p(x)
应该如何解决 例如
p(x) = 0.3
1
2π
exp
(x 2)
2
2
+ 0.7
1
2π
exp
(x + 2)
2
2
(4-7)
f (x)设定(4-2)时,概率密度曲线p(x )函数 f (x) · p(x)像如4-1
4-1 实际分布p(x) f (x) · p(x)的函数图像
- 21 -
哈尔滨工业大学本科毕业设计(论文)
时,p(x)布,
的,因,
p(x)中采样出N个样本并不是一件简单的工作。为此,我们引入舍弃采样来解决
在任意分布上采样的问题。
p(x)样,
q(x)样,样,
q(x)p(x ) 此,我们一个q(x)为提分布,个分
布需要满足以下条件
[27]
p(x) < Mq(x), M < (4-8)
中,M数,于,q(x)p(x)
p(x)/q(x)xX在下M的角看,提议
M倍后,应该“覆盖”,或者说“包着”实际分布p(x),例如,对于式(4-7)
p(x),当M = 2.3且提议分布q(x)
q(x) =
1
3
2π
exp
(x + 1.3)
2
2 × 3
2
(4-9)
q(x ) N(1.3, 3)时,实际分布p(x)与提议分布q(x)的图像如图4.2 所示
4-2 实际分布p(x)与提议分布q(x)的函数图像
由于议分布是个常规的斯分布,我们有系列的成方法可以在其
上采出多个样本。假设我们样得到一样本后,我们有种选么接
本,并将p(x)的,本,认
这个样本与p(x)采样的样本差距太大,不能看做是p(x)的采样样本。
然而,我们什么时候应该接受q(x)的样本作为p(x)的样本,什么时候又应该拒
绝呢 为了刻画这个事件,我们引入了接受概率的概念。假定我们现在已从q(x)
采样得到一个样本x
(i)
,则其接受概率A我们定义为
[16]
- 22 -
哈尔滨工业大学本科毕业设计(论文)
A =
p(x
(i)
)
M · q (x
(i)
)
(4-10)
计算得到接受概率后,我们以A作为接受样本的概率,但在计算机中,没有一
“以A本”这为,仿为,
[0, 1]U(0, 1)uu < A本,
则拒绝。通过这样的方式,我们便可以模拟“以A为概率接受样本”。我们很容
将一个样本推广到N个样本的情况,其具体描述如算法4-1所示。
Input: 真实分布p(x)提议分布q(x)采样量N
Output: N个采样样本{x
(i)
}
N
i=1
1 i = 1;
2 repeat
3 采样x
(i)
q(x),获取随机数u U(0, 1)A =
p(x
(i)
)
M·q(x
(i)
)
4 if u < A then
5 接受样本x
(i)
作为p(x)的样本,i+ = 1
6 end
7 else
8 舍弃样本x
(i)
i保持不变
9 end
10 until i = N;
算法 4-1 舍弃采样算法
义, A(x
(i)
)
p(x
(i)
)Mq(x
(i)
)度。4.2ABC点,
本,q(x)言,A
最大,次是B近,再C附近。而,对p(x)言,采样出现
B附近概率出现C附近率要小,因此,q(x)样得
样本直接作为p(x)的采样样本是不合适的。但由于
p(x
B附近
)
M · q(x
B附近
)
<
p(x
C附近
)
M · q (x
C附近
)
(4-11)
B使q(x)B本,C
大的接受概率使得我们保留了q(x)采样样本中C点附近的大量样本,经过舍弃阶段
后,我们便可以从q(x)的采样样本中筛选出可以刻p(x)质的样本,因此,舍弃
操作可以看做是对样本的纠正。
- 23 -
哈尔滨工业大学本科毕业设计(论文)
q(x)定义为式(4-9)p(x)定义为式(4-7)M = 2.3的情况下,4-3 a)q(x)
采样样本的概率分布直方图,将这些样本经过舍弃后,其分布直方图如4-3 b)
示。出,q(x)的,
逼近布,此我样本p(x)的采
而不再需要从p(x)中直接采样。
a) q(x)与样本分布直方图 b) p(x)与筛选后的样本分布直方图
4-3 舍弃采样的逼近效果
实上,(4-7)依然于特殊,其概密度是两一维斯分的线
组合,如果我们将其扩展到二维情形,例如,当真实分布p(x)与提议分布q(x)分别
定义为
p(x) =0.2 ·
1
2π
exp
(x + 1)
2
+ (y + 1)
2
2
+
0.1 ·
1
2π
exp
(x 3)
2
+ (y + 3)
2
2
+
0.7 ·
1
2π
exp
(x 2)
2
+ y
2
2
(4-12)
q(x) =
1
2 × 2
2
· π
exp
(x 1.5)
2
+ y
2
2 × 2
2
(4-13)
M = 3时,真实分布与提议分布的图像如图4-4 所示
以上子都于简单,实际中们遇的一般都高维情形,概率密度
更为复杂。这将会导致一个结果,提议分布q(x)了“包裹”真实分布p(x)M
使q(x)度。
形,p(x)中,有峰,M
它,言,M便
覆盖它们,了使p(x) < M · q(x)成立,M要取大的值,过M使
A = p(x)/Mq(x)小,使
样。因,q(x)
- 24 -
哈尔滨工业大学本科毕业设计(论文)
a) 全视图 b) 剖视图
4-4 二维真实分布(彩色)与提议分布(灰色)
p(x) < M · q(x)。为了解决这个问题,我们将引入重要性采样,这种方法可以使
我们不受约束地选取任意的q(x)
4.3 重要性采样
回顾章节4.1中的讨论,我们为什么要使用舍弃采样 因为蒙特卡罗方法中积
(4-4)p(x)样,(4-5)
分。采样q(x)
p(x)的样本,式(4-5)从而得以进行下去。
(4-5)之所以能成立,是因为我们利用了点质量函数来逼近概率密度,即
[27]
p
N
(x) =
1
N
N
i=1
δ
x
(i)
(x) (4-14)
式中,δ
x
(i)
(x)x
(i)
处的脉冲函数。下面我们将简单证明式(4-14)的正确性
1
为了得到概率密p(x)我们可以x近以x为中心建立一个小区域A,其
应的体积V
A
,此时我们从p(x)机采N个样x
1
, x
2
, x
N
,那么这些样中落
入区域A中的概率为
P(x A)
1
N
N
i=1
1(x
i
) (4-15)
式中,1(x
i
)为示性函数,其定义为
1(x)
0, x A
1, x A
(4-16)
1
感谢刘家锋老师的指点
- 25 -
哈尔滨工业大学本科毕业设计(论文)
际上,(4-15)类似数的用,根据本估度,
但同时,根据连续性我们也可以得到点x的概率密度,即
P(x A) =
A
p(x)dx (4-17)
A 时,V
A
0 A 等,
p(x)是常数,因此有
P(x A) =
A
p(x)dx = p(x)
A
dx = p(x)V
A
(4-18)
联合式(4-15)与式(4-18),有
p(x)V
A
1
N
N
i=1
1(x
i
) (4-19)
p(x)
1
V
A
1
N
N
i=1
1(x
i
)
1
N
N
i=1
1(x
i
)
V
A
1
N
N
i=1
δ(x
i
)
(4-20)
因此式(4-14)成立,证明完毕。
倘若们不用这逼近式,而采用外一种,在绍这方式前,我
们先引入所谓的重要性权值w(x),即
w(x) =
p(x)
q(x)
(4-21)
式中,q(x)为任意一个分布。此时,新的逼近方式可以陈述为
[27]
ˆp
N
(x ) =
N
i=1
w(x
(i)
)δ
x
(i)
(x ) (4-22)
比式(4-14)们可p
N
(x )1/N重要值恒1/N。引
要性权值后,积分式(4-4)可以改写为
I
f
=
+
−∞
f (x)w(x)q(x)dx (4-23)
对应的,式(4-5)改写为
ˆ
I
f
N
i=1
f (x
(i)
)w(x
(i)
) (4-24)
考,于,我 f (x)
p(x) f (x)在分p(x)望,p(x)
式,(4-5)分,q(x)
目标函数改写为
- 26 -
哈尔滨工业大学本科毕业设计(论文)
ˆ
f (x) =
f (x)p(x)
q(x)
= f (x)w(x) (4-25)
则积分式(4-4)变为
ˆ
I
f
=
+
−∞
ˆ
f (x)q(x)dx (4-26)
此时我们又可以使用类似于式(4-5)的方式来计算积分了。
言,q(x )束,
不存舍弃行为,这使得算效率相对舍弃采样有所高。但重要性采样也
其内在缺点,即q(x)取的好坏程度影响着积分的精度,若q(x)选取得不好,则需
度。q(x)
ˆ
I
N
f (x)差,
var
q(x)
f (x)w(x)
= E
f
2
(x)w
2
(x)
I
2
( f ) (4-27)
由于I
2
( f )q(x)无关可以摄取,再利用Jensen不等式,有
E
f
2
(x )w
2
(x )
E
2
|f (x )|w(x )
=
|f (x )|p(x)dx
2
(4-28)
因此提议分布可以选取为
q(x) =
|f (x) |p(x)
|f (x )|p(x)dx
(4-29)
管,|f (x)|p(x)样,
用,用,|f (x)|p(x)
数。点,p(x)使
|f (x)|p(x)大,高,
源。
无论舍弃样还是重性采样都独立样,即样本间是独立的,从
采样率较低。为提高采样率,我们可以使关联采样,即样之间存在
联,构建样本之间的关联性所要用到的便是著名的马尔可夫链。
4.4 马尔可夫链
正式入马可夫链之前,我打算从一个随游走例子入手。想象
内,N子,走。
对于一个粒子言,每一次走的步长相等的,只是角随机选择。当粒
移动正方形的界是,它将反弹回正形区域内。直觉的想象,经过漫
的时间,粒子将漫在整个正形区域内。4-5 示是个随机游的例子,
- 27 -
哈尔滨工业大学本科毕业设计(论文)
其中蓝色的初始状态在中心附近,绿色的初始状态在左下角。
4-5 两个随机游走的例子
这个子类于布朗运动,有的现是,起始位的选取并会影响最
结果终将均匀布。正如一未加的汤,无论从哪位置下,最
终整锅汤的咸淡是均匀的。对于某个特定的粒子而言,追踪它的轨迹是无意义的,
从宏上看,粒子下一步处哪个位置之前的位置无关,只它当前的位置
关,因为它是经怎样的路径到达当的状态对下一移动到哪里起不到何作
用。
尔可也是同一理,假们的x得状s个,
集合S = {x
1
, x
2
, x
s
}被称状态空间,马尔夫链刻画是变x状态空间S
个状之间迁移的轨迹。类于随机游的例子,马尔可夫链下一个状态与
前的状态无关,只与当前的状态有关,即
p(x
(i+1)
|x
(i)
··· x
(1)
) = p(x
(i+1)
|x
(i)
) (4-30)
这个质也被称为马可夫性质。对于定的系统,我们定义个状态转移到
一个状态的概率为转移概率为
p(x
(i+1)
|x
(i)
) = T (x
(i)
x
(i+1)
) (4-31)
4-6 系统,状态{A, B, C},由的参我们易算转移
T
T =
T (A A) T (A B) T (A C)
T (B A) T (B B) T (B C)
T (C A) T (C B) T (C C)
=
0 0 1
0.6 0 0.4
0 0.2 0.8
(4-32)
- 28 -
哈尔滨工业大学本科毕业设计(论文)
4-6 马尔科夫链
ABC义,A雨,B云,
C天,雨,10况。
先,我们可以很容易地将今天的天气描述为一个向量
x = [1 0 0] (4-33)
为了计算10天后的天气,用x 乘以10 次转移矩阵后将得到10天后的天气状况,即
[1 0 0] ×
0 0 1
0.6 0 0.4
0 0.2 0.8
10
= [0.091 0.151 0.758] (4-34)
也就是说,10天后下雨的概率为0.091多云的概率为0.151晴天的概率为0.758
倘若们假今天天气多云,用同的方法,我可以算得10
的天气状况为
[0 1 0] ×
0 0 1
0.6 0 0.4
0 0.2 0.8
10
= [0.091 0.151 0.758] (4-35)
我们现,不管今是雨天开多云,计算10天后天气情况十分接近
(这里完全一样是因为我们舍去了尾部小数)如果读者有兴趣的话可以验证初
状态晴天得到结果是一样的。就是说,不今天天气何,对10
后的天气均无影响
2
之所出现这种现象因为马尔可夫在第十个周期已经进入一个们称
之为稳的状态。似于之前随机游走,当经足够长的间后,系统的状
与初状态无关联,只系统的结(也就是转矩阵)有关。并不是所
的转移矩阵都能达到平稳,在这里,我们并不打算深入讨论,只给出结论定理
2
需要解释一下,这个天气系统是我们假设的,实际中的天气系统并不会如此简单
- 29 -
哈尔滨工业大学本科毕业设计(论文)
定理 4.1 的,t
s
t > t
s
时,
马尔可夫链到达一个平稳分布x
,其中x
满足
x
= x
T (4-36)
所谓态遍历,即要求马可夫是不约且周期的,所不可约,即
的,发,态,期,
即马尔可链不会陷入某个状态间循环,满足上述个条件的马尔可夫我们
称它是各态遍历的。
利用尔可链的这个质,我们就以实现关采样。由于始状态与
关,置,走,便
以作一个本。以上讨均基于一前提,即转矩阵已知的。然而,实
中,我们并知道移矩阵的值。例如,我们并不知由晴天转到多云的
率是0.2,这个数值是我们捏造的。但是一旦转移矩阵知道了,采样问题便迎刃而
解,目前成的马尔可夫链特卡罗方整体框架都是似的,不同的地方往
在于转移矩阵的构造上。
4.5 Metropolis-Hastings算法
似,Metropolis-Hastings(以MH法)
布,q(x
|x),不是,
强约束,p(x) < Mq (x )MH中的分布要满q(x
|x ) > 0可,
束,使
立了。另一不同点在于,MH法中的提分布其意义为当前状态x 下,
q(x
|x )x
x
上,这里,接受概率定义为
A =
p(x
) · q(x|x
)
p(x) · q(x
|x )
(4-37)
时,若接受A > 1接受个新态,否则,以概A接受态。若
受了这个新状态x
,则状态x转移x
处,并在x
处的提议分布q(x
∗∗
|x
)产生一个
新的试探状态x
∗∗
,如此反复循环,若不接受这个状态x
,则状态仍然停留x处。
是,MH中,q(x
|x)x
的,如,q(x
|x )x心,2
高斯分布,q(x |x) N(x, 2),那么如图4-7所示,在x
(1)
状态和x
(2)
状态下的提议
分布是不同的。
- 30 -
哈尔滨工业大学本科毕业设计(论文)
4-7 不同状态下的提议分布
综合以上的讨论,MH算法可以描述为算法4-2 中的过程。
Input: 真实分布p(x)提议分布q(x
|x )游走次数N
Output: 1个采样样本x
(N)
1 设置初始状态x
(0)
i = 0;
2 repeat
3 采样x
q(x
|x
(i)
),获取随机数u U(0, 1)
4 计算接受概率A =
p(x
)·q(x|x
)
p(x)q(x
|x)
5 if u < A then
6 x
(i+1)
= x
7 end
8 else
9 x
(i+1)
= x
(i)
10 end
11 until i = N;
12 返回x
(N)
算法 4-2 Metropolis-Hastings算法
样,本,MH
样本停留在当前状态。另一个不同点在于,算法4-2述的是采样出一个样本的过
程,是一个机游走的程,而算法4-1述的采样N个样的过程。尽管算
4-2只能采样一个样本,但是我们也可以很容易将其展成为残N本的
算法。外,由于各样本的随游走独立的,不在线程安问题,因此
- 31 -
哈尔滨工业大学本科毕业设计(论文)
4-2可以很容易设计成为并行算法。
如我的,如们使形式q(x
|x ) N(x, 2)提议
1000(4-7)p(x)本,N4-8
所示
a) N = 10 b) N = 100
c) N = 1000 d) N = 100
4-8 不同游走次数下的样本分布直方图
从图中我们不难发现,在游走次数N = 10时,逼近效果并不完美,随着N的增
大,当N = 100时,采样结果已经能很好地刻画实际分布了。此时,N再增大(比
10005000)已经差别不大。从随机游走的角度上看,可以理解为,N = 100
就已经进入平稳分布,再继续游走下去并没有太大意义。
MH MCMC 板, MCMC
MH例。MHMH
限性。先,估计态,即N
定。次,MH好,杂,
MH域,
探状不断地被决,从而长间留滞在点附近。接受概的存在,使得游
- 32 -
哈尔滨工业大学本科毕业设计(论文)
率低下,Gibbs采样MH的一例,这方法在接率,或
说接受概率为1,因此每一次游走都将得到一个新的状态,这个特性将大大地加快
收敛速度。
4.6 Gibbs采样
Gibbs采样又称为热浴方法或“Glaber动力学”
[16]
,常用于解决高维分布中的
采样问题。假设我们有一个d维向量x,并且知道任一分量的条件概率分布形式
p(x
j
|x
j
) p(x
j
|x
1
, ··· , x
j1
, x
j+1
, ··· x
d
) (4-38)
则我们构建提议分布
[27]
q(x
|x ) =
p(x
j
|x
j
) x
j
= x
j
0 其他
(4-39)
Gibbs采样MH特例,MH样的率公(4-37)
述为
A = min
1,
p(x
) · q(x|x
)
p(x) · q(x
|x )
(4-40)
将式(4-39)代入式(4-40),并利用x
j
= x
j
性质以及贝叶斯公式,有
A = min
1,
p(x
) · p(x
j
|x
j
)
p(x) · p(x
j
|x
j
)
= min
1,
p(x
) · p(x
j
|x
j
)
p(x) · p(x
j
|x
j
)
= min
1,
p(x
j
)
p(x
j
)
= 1
(4-41)
由式(4-41)不难得出论,Gibbs接受率恒1,亦Gibbs采样中,
我们存在丢弃样本状态停滞行为,每一次都会转到一个新的状上,这
显然会加快算法的收敛速度。
涩,便解,Gibbs
理。先,Gibbsp(x)
分布的,即p(x
j
|x
1
, ··· , x
j1
, x
j+1
, ··· , x
d
)知。如条件
的,使Gibbs略,Gibbs
的。(4-39)布,
x
1
, ··· , x
j1
, x
j+1
, ··· , x
d
d 1变,d个,
- 33 -
哈尔滨工业大学本科毕业设计(论文)
x
j
。如果将Gibbs采样试想成为一只章鱼,那么每次它都只迈出一只脚,当这只
脚固定后,再迈出剩下的另一只脚,因此,Gibbs采样的算法描述如算法4-3所示。
Input: 各个维度的条件分布p(x
j
|x
j
)游走次数N
Output: 1个采样样本x
(N)
1 设置初始状态x
(0)
i = 0;
2 repeat
3 采样出第1个维度x
(i+1)
1
p(x
1
|x
(i)
2
, x
(i)
3
, ··· , x
(i)
d
)
4 采样出第2个维度x
(i+1)
2
p(x
2
|x
(i+1)
1
, x
(i)
3
, ··· , x
(i)
d
)
5
.
.
.
6 采样出第 j个维度x
(i+1)
j
p(x
j
|x
(i+1)
1
, ··· , x
(i+1)
j1
, x
(i)
j+1
, x
(i)
d
)
7
.
.
.
8 采样出第d个维度x
(i+1)
d
p(x
d
|x
(i+1)
1
, x
(i+1)
2
, ··· , x
(i+1)
d1
)
9 until i = N;
10 返回x
(N)
算法 4-3 Gibbs采样算法
此,MCMC 毕, 第三章 题。
第三章中,式(3-33),即
ln L
ˆv
∂θ
= E
p(h|ˆv)
E(ˆv, h)
∂θ
+ E
p(v,h)
E(v, h)
∂θ
(4-42)
说,的,理,
题, O(2
n
v
+n
h
) 算,
MCMC理。
E(v,h)
∂θ
p(v, h)望,(3-7)E(v, h)义,
取。p(v, h)本,便解。
p(v, h)是一件困难的事,幸运的是,我们知道p(v, h)的条件概率p(v|h)以及p(h|v)
即式(3-22)和式(3-23)因此我们完全可以通过Gibbs采样,经过多次状态转移后
样出一个样本,再以同样的方法采样出多个样本,利用这多个样本,加以(4-5)
便可以算出期望值,整个问题便解决了。
- 34 -
哈尔滨工业大学本科毕业设计(论文)
4.7 对比离差
尽管第三章遗留的问题可以通过Gibbs样解决,但事实上,正如我们前面
及到的,马可夫进入平稳布的时间以确定。我们知道,马可夫链的
始状态对稳分布在性质是没有影响的,但是不同初始状态会影响进平稳
分布时间。就如往汤里加盐,在同的位置下并不会响最后的淡,但
度,Gibbs理,
响。如果置,型的慢。Hinton了一
[28]
Contrastive DivergenceCD法,
现了,那么说明这个数据是接近于平稳分布的,因此我们令初始值为该数据样本,
进行吉布斯采样,所以,对比离差算法如算法4-4所示。
Input: 条件分布p(h|v)p(v|h)迭代次数k
Output: 1个采样样本v
(k)
1 设置初始状态x
(0)
= datai = 0;
2 repeat
3 采样出h
(i)
P(h|v
(i)
)
4 采样出v
(i+1)
P(v|h
(i)
)
5 until i = k;
6 返回v
(k)
算法 4-4 CD-k算法
4-4也被CD-k算法,k的增大,样得的样接近型的
布,中,k = 1果,
k = 1。而得到最终的采样样本v
(k)
后,对数似然的梯度近似为
ln P(v)
w
i, j
P(h
i
= 1|v
(0)
)v
(0)
j
P(h
i
= 1|v
(k)
)v
(k)
j
(4-43)
ln P(v)
b
vi
v
(0)
j
v
(k)
j
(4-44)
ln P(v)
b
i
P(h
i
= 1|v
(0)
) P(h
i
= 1|v
(k)
) (4-45)
CD-k算法可以认为是利用
CD
k
=
h
P(h|v
(0)
)
E(v
(0)
, h)
∂θ
+
h
P(h|v
(k)
)
E(v
(k)
, h)
∂θ
(4-46)
- 35 -
哈尔滨工业大学本科毕业设计(论文)
来近似
[29]
P(v)
∂θ
=
h
P(h|v
(0)
)
E(v
(0)
, h)
∂θ
+
v,h
P(v, h)
E(v, h)
∂θ
(4-47)
CD-kWb
v
b
h
兹曼机来刻画数据的分布。
4.8 本章小结
本章蒙特罗的核心想说起,引舍弃采样,于舍弃采的提议分
束,样。样,
都属于非关联采样,因此我们引入马尔可夫链,得到一个关联采样方法,即MH
样。MH好,使低,
Gibbs样,通Gibbs
第三章的期望问题,但Gibbs的收敛速度依赖于初始值的设定,为了选取一个较
的初值,也为了快算法的敛速度,我们引了对比离方法。通过对比
差,可高效解决第三章中期望题。事实上,尔可链蒙特卡方法
潜力不仅局限于此,这套法在机器习中还有更为广泛的应用,然而我们
没有涉及。至此,受限玻尔兹曼机的内容讨论完毕,通过一个训练好
RBM
,就
可以画数据的分布。但目的讨论并有进入到核心容,我们仍没有讨论
别,或者说分类问题。在第五章中,我们将介绍如何用多个RBM为砖块垒出
个深度置信网络,并用这个网络进行图像识别。
- 36 -
哈尔滨工业大学本科毕业设计(论文)
5 深度置信网络
Hinton2006络,
的深神经网络的训是及其困的,然而在深度置信络中,我们采用网络
逐层练,随后对网络参数微调,这种策略使得我们可以容地训练多层神
网络。由于度置网络本质一种传统经网络的广,在本章中,我们将
传统神经网络说起,介绍其训练方法,逐步将其推广到深度置信网络。
5.1 神经网络组成及表达能力
一个经网往往由多神经元组成,神经元作网络基本单元,在给
恰当激活函数和权的前提下,只要个网络足够庞大,足容纳较多的神
元,那么这个网络可以表达任何一个连续函
[30]
,当然这只是一个理论上成立的
理想况,实际工中,我们没有办利用神经络来描述有的函数,但是
个定理能使我们对神经网络的表达能力充满信心。
5.1.1 神经元
一个神经元如图5-1 所示,它包含d个输入x = [x
1
, x
2
··· , x
d
]
T
以及对应的d个权
w = [w
1
, w
2
··· , w
d
]
T
,还一个偏置b此外,还应包括个执非线性映
的激活函数 f ( · )
5-1 神经元
d个输入x = [x
1
, x
2
··· , x
d
]
T
直接相连的是数据的输入,例如,一张28 × 28
入,28 × 28 = 784量,
784入,x = [x
1
, x
2
··· , x
784
]
T
d
w = [w
1
, w
2
··· , w
d
]
T
刻画了d个输入x = [x
1
, x
2
··· , x
d
]
T
的重要性,w中的某个分
w
i
越大,明对应的x
i
对最决策果的影响大。从生物的角度上看,
- 37 -
哈尔滨工业大学本科毕业设计(论文)
x相当于给予生物各种刺激,w相当于该生物对各种刺激的敏感度。例如,我们
用神经元设计一个医学诊断系统来判定一个人是否需要住院观察,对于该神经元,
假设输入为x = [心脏疼痛, 头疼, 腰疼]如果有某个症状,则对应位置1否则置0
显然,若一人心疼痛,我们更倾于让他住观察,因此我们心脏疼痛
应的值设定一较大的权w
1
= 0.9头疼次之,我们定为w
2
= 0.5当一
时,疗,w
3
= 0.1
此,这个神经元的权值为
w = [0.9, 0.5, 0.1]
T
(5-1)
假设在有位患者来医院,他既头疼又有脏疼的症状,那么这
患者可以表示为向量
x = [1, 0, 1]
T
(5-2)
此时,病情积累的严重性为
w
T
x = 0.1 + 0.9 = 1 (5-3)
此,b
事。b = 0.7w
T
x > b,则病,
察,网络输出y = 1,否则这位患者不需要住院,网络输出y = 0。如果我们定义
神经元的净激活为
net = w
T
x + b (5-4)
净激活可理解为排除偏干扰后神经元接收的刺激总和。那么上述判过程
相当于用一个阶跃函数对净激活作一个非线性映射,即
y = f (net) =
1 w
T
x b > 0
0 其他
(5-5)
中, b 数,w
T
x + bw
T
x b 别。 上,
b = 0.7神经元做的决策,其果只由心疼痛个因素决定,因如果
个患者没心脏疼痛,那么最大的净活是在他即患头疼又患有腰疼的况下
得,此w
T
x = 0.60.6 < 0.7,并院。此,上元,
换成价的逻辑题便一个人的状中含有脏疼痛,则需要院,否
则不需要住院。如果我们把偏置调低,另b = 0.55,则此时等价的逻辑命题为
果一人的症状中含心脏疼痛,或者状中既含有头有含有腰疼,则需要
院,否不需要住院。综合以上论,偏置起的是值的作用,是这个阈
了,题,
- 38 -
哈尔滨工业大学本科毕业设计(论文)
这取决于系统的期望输出是什么。
神经总能换成一个应的逻辑达,需要提的一因果关系是,我
并不是从辑表达中推出经元的参数,而是从神经的参数中可以得到个逻
辑表达。神经元的点在于,通一个经元,便可实现一个单的策,如
果拥更多的神经元,将他组合起来成一个神经网络,便以实现更为复
的决行为。这个策的因果系是由参决定的,后面我将会看到,参数
通过计学习学到的,因此神经网络中,我不需要对事物因果关系进行
析,只需要使用大量的数据网络学习中的因果关系,这些果关系对于我
而言是透明的。
5.1.2 逻辑表达
在本小节,我们将再一次讨论网络的逻辑表达能力,如图5-2 所示的一个接收
两维输入的神经元,其偏置w = [2, 2]
T
,偏置b = 3
5-2 与非门的神经元表达
们的假,即x = [0, 0]
T
x = [1, 0]
T
x = [0, 1]
T
真,y = 1真,x = [1, 1]
T
假,即y = 0。事实上,图5-2等价于逻辑电路中的与非门,即
y = x
1
· x
2
(5-6)
由于非门通用门,利多个与非可以建出三大辑门门、或门、非
门。此,5-2数。如,
中,其逻辑函数为
y
1
= x
1
x
2
(5-7)
y
2
= x
1
· x
2
(5-8)
5-3 a)示,5-3
- 39 -
哈尔滨工业大学本科毕业设计(论文)
b)所示
1
a) 由与非门搭建的半加器 b) 由神经元搭建的半加器
5-3 半加器的两种不同描述
我们所以花费幅去介绍经元的表能力,是为了说神经网络确实
实现些逻辑决策,但并不味着网络权值需要我们工设定的。这里的权
之所要手工设定,是因为们精心筛出来用以阐述经网络的表达力,但
实际用中,权值通过误差播自动学的,学习到的权值,其应的逻辑
题对于人类而言是难以理解的,但这并不重要,因为我们需要的是仅仅决策结果,
而不是这个决策是如何产生的因果关系。
5.2 神经网络的前馈
一般言,神经网是一个多结构织,网络的一层都由个神经元
成,后一层神经由前一层神经元激活。同层的神经之间没有接,因
此同层节点的激活独立的。神经网接收到一个数后,逐层地激活各层
神经元,前层的出作为后层的输入,最后到一个输结果。这个过程
为神经网络的前馈或前向传播。
5-4 神经网络的前馈
1
图中,为了美观,我们并没有将偏置画出来
- 40 -
哈尔滨工业大学本科毕业设计(论文)
如图5-4所示是一个三层神经网络,由于神经激活是自底向上传播的,如果各
层的激活函数都相同,为 f ( · ),则网络的第k个节点的输出为
z
k
= f
n
y
j=1
w
k j
f (
n
x
i=1
w
ji
) + b
j
) + b
k
(5-9)
中,w
k j
y jzk值,w
ji
x层的i
节点y层的 j节点之间的连接权值,b
j
y层第 j个节点的偏置,b
k
z层第k
节点的偏置。
神经络的种自底向的激活,有也被解释特征取或重新码。当
接收一个数据时,神经网将这个数逐层地进行特抽取,过滤掉一些冗
息,码,(即层)
特征进行分类,从而完成整个识别过程。
5.2.1 神经激活
到目为止,们只介绍一种活函数,即跃函数,但实际中们并
会使阶跃数作为激函数。首先,跃函数是连续的,其次,阶跃函数
不可导的
2
。激活函数不可导,将导致网络无法利用反向传播进行训练,关于这点
我们将在反向传播章节讨论。作为激活函数,它应该满足以下几个条件
1. 须是线性的。(5-9)可以出,若函数线的,则层神
经网络实际上只相当于两层网络,因为多个矩阵相乘的结果仍为一个矩阵。
网络一旦失去多层结构,则表达能力迅速下降。
2. 应该有饱特性,至少在一上界下界。饱和性的在,使
得神经元的输出不至于过高或过低,整个网络的编码维持在一定的范围内。
但最近的研究表明,一些近似饱和的激活函数也能工作得很好,如此看来,
饱和似乎并不是必要的。
3. 应该连续可导。由于向传播中要求激活函数对于净激的偏
导数,如果激活函数是不可导的,那么反向传播算法将无法执行。
中, sigmoid
3
数。 中,
sigmoid函数我们定义为
f (net) =
1
1 + e
net
(5-10)
其对应的图像如图5-5所示
2
事实上阶跃函数是可导的,其导函数为脉冲函数,这是一个广义函数,我们不深入讨论
3
也被称为logistic函数
- 41 -
哈尔滨工业大学本科毕业设计(论文)
5-5 sigmoid激活
可以看到,sigmoid数是一个值域(0, 1)的连续可导函数,其导函数有一个
重要特性,即
f
(net) =
e
net
(1 + e
net
)
2
=
1
1 + e
net
1
(1 + e
net
)
2
= f (net)
1 f (net)
(5-11)
这个特性之所以重要,是应为利用式(5-11)可以直接通过网络的输出直接计算
激活函数相对于净激活的偏导数而不必引入额外的计算。我们看到,sigmoid函数
(0, 1)候,我(1, 1)使
正切函数,即
f (net) = tanh(net) =
e
net
e
net
e
net
+ e
net
(5-12)
其对应的图像如图5-6所示
5-6 tanh激活
近年来,在神经网的研究上提出一些新的活函数,其最重要的
- 42 -
哈尔滨工业大学本科毕业设计(论文)
ReLU激活函数,其定义为
[31]
f (net) =
net net > 0
0 其他
(5-13)
(5-13)也可以简写为
f (net) = max(0, net) (5-14)
其对应的图像如图5-7所示
5-7 ReLU激活
这种激活函数相比于sigmoid数有较大的改进,关于其优点我们将留到反
播的论。但ReLU有一net < 00从而传播
无法更新参数。因此,在ReLU的基础上又产生了一些变体,例如,softplus中,激
活函数定义为
[31]
f (net) = log(1 + e
net
) (5-15)
其对应的图像如图5-8所示
5-8 softplus激活
- 43 -
哈尔滨工业大学本科毕业设计(论文)
出,softplusReLU版,softplus
论是,其激活函数的导数为logistics函数,即
f
(net) =
e
net
1 + e
net
=
1
1 + e
net
(5-16)
然而这个结论并没有什么用处,因为它并不能减轻程序的计算量。
ReLU的另一种变体是由He Kaiming等人提出的PReLU,其激活函数定义为
[23]
f (net) =
net net > 0
αnet net 0
(5-17)
式中,α为一个较小的参数,例如当α = 0.1时,其图像如图5-9所示
5-9 PReLU激活
显然,PReLU负半面不会出现导0的情况。尽管参数α需要学习
到,但这种方法ImageNet 2012数据集上获得了非常好的识别效果,首次在图
识别任务上超越了人的识别效果,错误率仅为4.94%。在该文中,作者提到了一个
有意思的现象在较低层的网络中,学习到的参数α较大,而在高层的网络中,参
α较小。作者的猜测是较低层网络需要尽可能多地保留数据的信息,因此激活函
数更向于类线性,而高层网更倾向于象数据的构,从而做出决策,因
高层的激活函数更倾向于非线性。
在同个任中,激活函数的同选会有不同实验象,目前并没有
明哪种激活函数更好。习惯上,在全连接神经网络中,我们更喜欢sigmoid派的
活函数,而在卷积网络中,我们更喜欢ReLU派的激活函数,尽管这些都不是强制
的。
- 44 -
哈尔滨工业大学本科毕业设计(论文)
5.3 分类器
神经络的层激活,其本质于将种编码转成另种编码。编码之
的转换,可过滤掉一些原编码中无的噪声或信息,这个程一般都伴随
熵的减小(但并不绝对)。然而,一个神经网络在最顶层的激活,其编码是人类所
无法解的,因此,在最顶层点之上还需要个分类器对神网络提取到的
征或说编码进行分类。分器其作用,一方在于将编码转为人类所能理
的编码,这有监督的分类务以及无督的聚类任务是必要的,因为我们
签。的,
因为维并不需输出标签。一方面,分类器带有一个则函数,这个准
函数义了熵,即义了么是混乱,么是有序。控制论的度上看,控
工程中,误差是系校正核心,没有差便没有馈,没有反馈,则系统难
控制。器学习也同样道理,没有差,则无法参数进行正,机器便
法从本中习。误差的源,源自于则的定义,预先预定么是的,什
的,差,差,
便正。中,差、
softmax支撑向量机,尽管支撑向量机是一种重要的分类器,但是鉴于篇幅有限,
我们并不打算在本文中介绍支撑向量机,关于其原理读者可参考文献[32, 33]
5.3.1 平方误差分类器
说,器,则,
这个准则除了在神经网络中有应用之外,在很多领域也有广泛的应用。平方误差,
或者说二范数,其准则函数定义为
J =
d
i=1
(x
i
t
i
)
2
(5-18)
中,x
i
出,定,t
i
值,号,定,dx数。
4点,[ 0.1 0.1 0.8 0.1 ]
[ 0 0 1 0 ](再调,定)
[ 0.1 0.1 0.2 0.1 ]
[ 0. 01 0.01 0.04 0.01 ](5-18)J = 0.07上,
J = 0.07对我们而言没有太大用处,它最多只能刻画总的误差量有多大,真正对我
- 45 -
哈尔滨工业大学本科毕业设计(论文)
们有的是平方误差量,利用这个向量,可将误差反向传回神经网络的
层,从而自向下网络参数行校正,关于这过程更多细节,我们将会
到反向传播章节介绍。
5.3.2 softmax分类器
际中,了方便类,我往往网络输出k中取1式,例
如,别,使话,可,
00表第类,01类,以类推。我们使所谓k中取1”形
式,我便四个点,0001表第类,0010代表类,0100代表
类,1000代表第四类。为了实现“k中取1的形式,我们需要引入softmax分类器,
softmaxlogistics广,使logistics时,
只能实现两类分类,而softmax分类器可以实现多类分类功能。
softmax中,nS =
(x
(1)
, y
(1)
), ··· , (x
(n)
, y
(n)
)
y c种, y
(i)
{1, 2, ··· , c}
(ϕ
1
, ϕ
2
, ··· , ϕ
c
)率,
ϕ
i
= 1
余,只需要c 1个记号(ϕ
1
, ϕ
2
, ··· , ϕ
c1
)即可,对于ϕ
i
,有
ϕ
i
= P(y = 1; ϕ) (5-19)
以及
ϕ
c
= P(y = c; ϕ) = 1
c1
i=1
ϕ
i
(5-20)
注意,正如我们之前提到的,ϕ参数存在冗余,所ϕ
c
并不是参数,而是一个为
了方便后面讨论所引入的一个记号。
由于softmax概率分布也属于指数分布族,而在指数分布族中,对于概率
布而言,都可以写成如下形式
P(y; η) = b(y) exp
η
T
T (y) a(η)
(5-21)
softmax中,我们记T (y) R
c1
T (1) =
1
0
.
.
.
0
T (2) =
0
1
.
.
.
0
··· T (c 1) =
0
0
.
.
.
1
T (c) =
0
0
.
.
.
0
(5-22)
- 46 -
哈尔滨工业大学本科毕业设计(论文)
T (y)
i
T (y)的第i个元素,记1{·}为示性函数,即
1{A} =
1 ,若命题A为真
0 ,若命题A为假
(5-23)
因为
T (y)
i
= 1{y = i},因此
E
T (y)
i
=
T (y)
i
· P(y = i)
= P(y = i)
= ϕ
i
(5-24)
P(y; ϕ) = ϕ
1{y=1}
1
ϕ
1{y=2}
2
···ϕ
1{y=c}
c
= ϕ
1{y=1}
1
ϕ
1{y=2}
2
···ϕ
1
c1
i=1
1{y=i}
c
= ϕ
T (y)
1
1
ϕ
T (y)
2
2
···ϕ
1
c1
i=1
T (y)
i
c
= exp
ln
ϕ
T (y)
1
1
ϕ
T (y)
2
2
···ϕ
1
c1
i=1
T (y)
i
c
= exp
T (y)
1
ln ϕ
1
+
T (y)
2
ln ϕ
2
+ ··· +
1
c1
i=1
T (y)
i
ln ϕ
c
= exp
T (y)
1
ln
ϕ
1
ϕ
c
+
T (y)
2
ln
ϕ
2
ϕ
c
+ ··· + ln ϕ
c
(5-25)
对比式(5-21),得
b(y) = 1 (5-26)
η =
ln
ϕ
1
ϕ
c
ln
ϕ
2
ϕ
c
··· ln
ϕ
c1
ϕ
c
T
(5-27)
a(η) = ln ϕ
c
(5-28)
定义
η
i
= ln
ϕ
i
ϕ
c
η
c
= ln
ϕ
c
ϕ
c
= 0 (5-29)
由于
e
η
i
=
ϕ
i
ϕ
c
(5-30)
- 47 -
哈尔滨工业大学本科毕业设计(论文)
ϕ
c
· e
η
i
= ϕ
i
(5-31)
ϕ
c
c
i=1
e
η
i
=
c
i=1
ϕ
c
e
η
i
=
k
i=1
ϕ
i
= 1 (5-32)
从而
ϕ
i
= ϕ
c
e
η
i
=
exp(η
i
)
c
i=1
exp(η
i
)
(5-33)
P(y = i; ϕ) = ϕ
i
=
exp(η
i
)
c
i=1
exp(η
i
)
(5-34)
以及
P(y = i|x; θ) =
exp(θ
T
i
x)
c
j=1
exp(θ
T
j
x)
(5-35)
上,softmax络,
络中使sigmoid函数作为活函数不同,在softmax器中,激活函数 f (net
k
)
e
net
k
,对应的激活概率定义为
[3]
z
k
=
e
net
k
c
i=1
e
net
i
(5-36)
式中,z
k
代表k节点激活的概率,net
k
代表k节点的净激活,取值为输入特
x的线数,即net
k
= θ
k
x
T
c总数。(5-36)母的下,我
们对每个类别的输出都进行了归一化,所以总的激活概率为1 在识别中,计算各
个类别的激活概率后,只需选取最大激活概率所对应的类别作为输出类别即可。
5.4 神经网络的反馈
神经络的馈是基于则函数的馈,准则函作为差的度量,刻画
网络输出与训练集标签两者间的差异。整个反馈程中,实质上就是准
函数优化的过程,即对网络参数进行新,使得误差不减小。假设一个
θ f (θ)θ使 f (θ)
程。 f (θ)的,Hessian定的,
题,我们可有很多策略解凸优化问题,但际中遇到的问基本都是非凸
题,解决非凸问题,一个简单有效的方法是利用梯度下降。想象我们在一座山上,
为了快速的下山,我们可以一步都朝当前最陡的方向(即梯度向)前
进,梯度下降也是基于这个原理,每一次迭代,我们都在当前θ计算 f (θ)的梯
θ
f (θ),让θ加上这个梯度分量,也就是让它朝着梯度下降的向迭代。由于梯
- 48 -
哈尔滨工业大学本科毕业设计(论文)
度下降的每一步都是基于当前的参θ,所以这是一个贪婪算法,并不能保证收敛
优。 f (θ)的,在大
(但对,响)而,性,
不可能收敛到全局最小值,我们得到的往往是局部极小值。另外,值得一提的是,
的,值,
一旦敛到此处,意味着网可以很好刻画训练集,但并不味它同样可以
好地化到测试集上,这个候往往会随着较高的过合风险,我们不应一
地最全局最小,应在训练与测试集者之间进一个权衡。梯度降,因
其简单有效的特点,称为优化问题中一个很常用的策略。
5.4.1 分类器参数校正
20世纪80年代前,人们并找到个较的方训练经网络,这种
直维1986年,这一RumelhartMecelland科学
4
出了向传播算法,首次在经网络中用梯度下降逐地训练网络参数,每
练完一层后将当前层的误差传递回前一层,依次迭代,最后完成整个网络的训练。
在这方法中,核点有何利最顶层(即类器)的误来更新最
层的参数及如何在某一网络更新完参数后该层的误差传播回一层,我们
将会在本小节中讨论最顶层的参数校正,并在下一小节讨论误差传播。
5.4.1.1 平方误差分类器参数校正
由于在平方误差分类器中,准则函数定义为
J(θ) =
1
2
c
i=1
(t
i
z
i
)
2
=
1
2
||t z||
2
(5-37)
式中,z
i
为训练集的标签值,而网络的输出t
i
又是由前一层的静激活经过非线性映
射后得到的,即
t
i
= f (net
i
) (5-38)
式中,net
i
为输出层的前一层,即倒数第二层的净激活,而这个净激活又被定义为
net
i
= wx + b (5-39)
式中,w为输出层与倒数第二层两者之间的权值,b偏置,因此,我们不难通
度,J(θ)θ(这θwb
4
事实上反向传播是由很多人在同一年代同时独立提出的
- 49 -
哈尔滨工业大学本科毕业设计(论文)
J(θ)
w
=
J(θ)
net
net
w
(5-40)
以及
J(θ)
b
=
J(θ)
net
net
b
(5-41)
如果此时的激活函数是sigmoid函数,那么容易知道
J(θ)
net
= net(1 net) (5-42)
如果激活函数是ReLU函数,也容易得到
J(θ)
net
=
1 net > 0
0 net 0
(5-43)
net/∂θ只是一个线性函数,同样容易求得
net
w
= x
net
b
= 1 (5-44)
(5-42)(5-43)
5
(5-44)便(5-40)(5-41)
度,即梯度。
5.4.1.2 softmax分类器参数校正
softmax的训练中,由于网络的输出为
z = E
T (y)|x; θ
= E
1{y = 1}
1{y = 2}
.
.
.
1{y = c 1}
x; θ
=
ϕ
1
ϕ
2
.
.
.
ϕ
c1
=
exp(θ
T
1
x)
c
j=1
exp(θ
T
j
x)
exp(θ
T
2
x)
c
j=1
exp(θ
T
j
x)
.
.
.
exp(θ
T
c1
x)
c
j=1
exp(θ
T
j
x)
(5-45)
对应的似然函数为
L(θ) =
n
i=1
P(y
(i)
|x
(i)
; θ) (5-46)
对应的对数似然函数为
(θ) =
n
i=1
ln P(y
(i)
|x
(i)
; θ)
=
n
i=1
c
j=1
ln
exp(θ
T
j
x
(i)
)
c
t=1
exp(θ
T
t
x
(i)
)
1{y
(i)
= j}
=
n
i=1
c
j=1
1{y
(i)
= j}ln
exp(θ
T
j
x
(i)
)
c
t=1
exp(θ
T
t
x
(i)
)
(5-47)
5
这取决于你的激活函数选取
- 50 -
哈尔滨工业大学本科毕业设计(论文)
(5-47)相反被称叉熵,练过充当函数,们对导,
∂ℓ(θ)
∂θ
j
=
n
i=1
c
j=1
1{y
(i)
= j}
x
(i)
∂θ
j
ln
c
t=1
exp
θ
T
t
x
(i)
=
n
i=1
c
j=1
1{y
(i)
= j}
x
(i)
exp(θ
T
j
x
(i)
)
c
t=1
exp(θ
T
t
x
(i)
)
x
(i)
=
n
i=1
c
j=1
1{y
(i)
= j}x
(i)
1 P(y
(i)
= j|x
(i)
; θ)
(5-48)
由于1{y
(i)
= j} {0, 1},所以写成向量形式为
∂ℓ(θ)
∂θ
j
=
n
i=1
x
(i)
1{y
(i)
= i} P(y
(i)
= j|x
(i)
; θ)
(5-49)
通过使用式(5-49)进行迭代,我们便可以使用梯度上升(下降)进行搜索,从而最
大化似然(或最小化交叉熵)来训练softmax分类器。
5.4.2 误差传播
为了单起见,我使用一个层神网络对误传播行讨论,但通过
里的讨论,我们可以很容易将神经网络扩展到多层结构。
5-10 三层神经网络的网路构型
5-10络,yz器,论,
以利用式(5-40)和式(5-41) 求取J(θ)/∂θ
yz
的值,如果我们要求取J(θ)/∂θ
xy
的值,
么通过链式求导,我们有
J(θ)
∂θ
xy
=
J(θ)
y
y
net
y
net
y
∂θ
xy
(5-50)
而我们又可以求得
J(θ)
y
=
J(θ)
net
z
net
z
y
(5-51)
如果我们定义式(5-40)以及式(5-41)中的误差为
- 51 -
哈尔滨工业大学本科毕业设计(论文)
δ
z
=
J(θ)
net
z
(5-52)
那么我们可以将式(5-51)写为
J(θ)
y
= δ
z
net
z
y
= δ
z
θ
T
yz
(5-53)
式中,J(θ)/∂y就是分类器输出层(Z层)的误差传播回其上一层(Y层)的误差,
如果我们定义Y层的误差为
δ
y
=
J(θ)
y
y
net
y
(5-54)
则我们可以利用后一层传播回来的误差δ
z
计算该层的误差
δ
y
= δ
z
θ
T
yz
·
y
net
y
(5-55)
从而我们可以利用该层的误差δ
y
计算该层参数w
xy
的增量,即梯度
J(θ)
∂θ
xy
= δ
y
·
net
y
∂θ
xy
(5-56)
通过式(5-56)对参数θ
xy
进行校正,校正完毕后,如果网络不止三层,而是四层,假
XP层,XPθ
px
度,
导,同样有
J(θ)
∂θ
px
=
J(θ)
x
x
net
x
net
x
∂θ
px
(5-57)
与之前的做法类似,我们有
J(θ)
x
=
J(θ)
y
y
net
y
net
y
x
= δ
y
· θ
T
xy
(5-58)
同样的道理,X层的误差δ
x
定义为
δ
x
=
J(θ)
x
x
net
x
= δ
y
θ
T
xy
·
x
net
x
(5-59)
则参数θ
px
的梯度便可以利用δ
x
计算
J(θ)
∂θ
px
= δ
x
·
net
x
∂θ
px
(5-60)
如果有更多的层,其原理雷同,我不再详细说。现在让我们开以上的
学内容从络的结构上解这个算法为什么叫误差反向传播,首先我们察各
层的误差,即
[δ
z
δ
y
δ
x
] =
J(θ)
net
z
δ
z
θ
T
yz
·
y
net
y
δ
y
θ
T
xy
·
x
net
x
(5-61)
式中,θ
T
起到的作用是将误差δ反向注入的行为,这个行为如图5-11所示
- 52 -
哈尔滨工业大学本科毕业设计(论文)
5-11 误差反向注入
(5-61)出,外,
的,如果用一句话概括反向传播算法,便是层的误差注入 1中,再乘
1激活数的数,得 1的误差,利这个到的差,对 1
的参进行新,更新完后,将 1误差重新入到 2层,重上述
骤直误差传遍整个络。但是这里有例外,最顶层的误差义与剩余层的
一样,之所会这样是因为顶层的误并不是通过注方式得到的,而是人
定义得到的,因为这个误差源自于准则函数。
我们以看到,反传播这种略实上与前向播是似的,反向传播
是一贪婪算法,这将会导一些问题。因为一次误差传播是更新参数后
将误注入回前一层,这并能保证计得到的梯度就真实的梯度,一旦网
的层数过深,将导致前面层的真实数与利用反向播计算得到的导数差过
大。另外,如果使用sigmoid数作为激活函数,它将很容易进入饱和状态,前
层的梯度接近于0,从而参数无法更新,这种现象我们称之为梯度消失。一种对抗
梯度的方是将sigmoid换成ReLU函数,关于ReLU么可抵抗
梯度消失的原理目前尚未研究出来,但是实验现象表明它确实能抑制梯度消失。
5.5 深度置信网络
度置Deep Belief Networks,简DBN质就传统
络,动。先,
络,构。外,
础,络。
5-12展示了一个深度为4的深度置信网络。
我们所以用深度结构,是为在经元总数变的提下,深度结构
表达能力比浅结构的表达能力更强。之所以要在这个结构中引入受限玻尔兹曼机,
- 53 -
哈尔滨工业大学本科毕业设计(论文)
5-12 DBN网络构型
是因传统的深度结无法训练。正如们前面提及到的,深结构会在网络
较浅出现梯度消失象,导致浅层无对参数进行校正。由数据必须从浅
神经逐层地传播到层神经元,一旦层的参数无法正,将会导致深层的
络也无法行参数校正,因为浅层参无法校正意味浅层无法对数据进合理
地重码,数据经过浅层后到的是混的数据,尽管深层不产生太大的梯
消失象,但数据过浅的打乱后,据已经混了,训练也便没有义。另
一方面,传的神经网络初值设定为机值,这些随机值一设定为一个均
0,方差较小的高斯分布,神经网络是一个非凸问题,局部最小值众多,网络最
后收敛到最小值取很大度上决于初始值的取,随机选取初始值虽然一个
可行方法,但是如果我们让参数的始值设定在一较合理的初始值,将
很大度地改善网络收敛性能,而受玻尔兹曼机一重要的贡献在于,将
度神经网络的参数初始化到一个较好的值。
段,段。
DBN的预训练阶段中,将相邻两层看做一个受限玻尔兹曼机,采用受限玻尔兹
曼机的训练方法,将原始数据作为最底层的输入,每RBM隐含层的输出作为后
一层的输入,然后进行逐层贪婪的无监督训练。对于每层RBM其训练过程描
如算法5-1所示
- 54 -
哈尔滨工业大学本科毕业设计(论文)
Input: 由前一层网络提供的含有n个样本的数据
S = {x
i
}
n
i=1
网络参数w, b
h
, b
v
动量项系数p
学习率η权衰减系数eCD-k中的参数k
Output: 训练好的网络参数
RBM提取到的数据S
= {y
i
}
n
i=1
1 for i = 1;i 1; i + + do
2 v
0
= v
t
= x
i
3 h
0
= sampling h given v (v
0
)
4 for j = 0; j < k; j + + do
5 h
t
= sampling h given v (v
t
)
6 v
t
= sampling v given h (h
t
)
7 end
8
w
= v
T
t
h
t
v
T
0
h
0
9
b
v
= v
t
v
0
10
b
h
= h
t
h
0
11 w = e (p w + η
w
)
12 b
v
= b
v
+ η
b
v
13 b
h
= b
h
+ η
b
h
14 y
i
= sampling h given v (x
i
)
15 end
算法 5-1 受限玻尔兹曼机训练算法
5-1中,η、动pe
技巧讨论,这些技巧在数推导的过中是不必要的,然而实际工程中是
要的,有时缺了们网络训会失败。当逐层练完毕后,网络参数已经
[34]
段,
行有督的权值微调。通过样的方法,可以免单纯地使用向传播方法中
出现陷入局部优问题,由识别的过中,数据是逐层进行维度化,所
DBN也可以认为是种特征提取方法,对应的,深度学习有时候也之为“特
征学习”
[35]
- 55 -
哈尔滨工业大学本科毕业设计(论文)
5.6 本章小结
本章中,我们从传的神经网说起,介绍神经的工作原以及神经
络的向传播。当数据经过经网络的层编码后,得到的编并不是人类所
理解的编码,因我们介绍了两种分器将这些编码换成自然语言所能述的
编码。随后们介了神经网的反向传算法,最后引出度置信网络。尽
“深络”,我“深络”短,
于深度置网络中并没有多额外的东西,很多思想是与传统神经网络相同
的,所以我花了大的篇幅介绍传统经网络。在本章中,我依然留下
些问没有决,即训练程中的一额外数,例如学率、动量项等,关
这些容,由于其偏向工程内容,们将其集到“神经网设计巧”章
节中讨论。
- 56 -
哈尔滨工业大学本科毕业设计(论文)
6 卷积神经网络
卷积经网络灵源自哺乳物的视觉统,它是唯一一不需要预训练便
络。LeCun1989络,
果,后,[19]
应用文档识别中,实现了可解数字串网络,这是一个大的突破,因为
涉及数字间的上下文。但积神经网在提出的二十年里一直默默闻,直
到最近几年,人发现在图像识别中积神经网络相于其他的模型能更地进
行特征提取才被重视。目前,几乎所有最好的识别系统都是基于卷积神经网络的,
从某种意义上而言,卷积神经网络相当于深度学习的代言人。
6.1 卷积神经网络综述
卷积经网可以看做一种特殊神经络,在深度信网络中,网络
点是全连接的,而卷积神经网络中连接是局部的。此外,卷积网络强制权值共享,
对比于深度置信网络,卷积网络的这些特性都体现着非常强的正则。
a) 全连接神经网络 b) 卷积神经网络
6-1 二维视觉下的全连接神经网络与卷积神经网络
如图6-1 a)所示为传统的全连接神经网络,我们可以看到,每一个上层节点与
下层点都含有连接,而所的连接都独立无关联的,即每连接权值都不
等。对应的,图6-1 b)示为卷积神经网络,在这种网络构型中,每个上层节点只
与部的下层节连接,并且,这些接的权值共享的,即相同色的连接
表其值相等。局部连接将大大减少络的连接数量,而权共享又会大大
少网的参数数量。例如在6-1 a)中,连接数量3 × 5 = 15,由权值不共享,
156-1 b)3 × 3使
3个。卷积网络的设计目的是让网络拥有更多的连接,而拥有更少的权值。尽管
- 57 -
哈尔滨工业大学本科毕业设计(论文)
这里接数量上卷积络要比全接网络少,但是我们面将会看到,卷积网
将通过多张特征图构造出更多的连接。
卷积经网络,一用于图像别与音识别两领域,因为两个领域
着明的二维特性。例如在图识别中,图像即以看做是维的,也可以看
的,的,量,
貌。的,
的原貌,利二维平面直角标系来描述。声之所以可看做二维的,是
为它有时间这维度,关于音识别,我们不多讨论,更多的节请参考
[36–38]
a) 全连接神经网络 b) 卷积神经网络
6-2 三维视觉下的全连接神经网络与卷积神经网络
由于积网保留了图的二维面貌,因此相比全连神经网络言,其
网络构型是一个三维构型,如图6-2 a)所示为三维视觉下全连接神经网络。由于上
层节是一个高维列量,我们可以认这个向量是一的,并且这个向量里
每一个元都与输入图像的每一个像素点连接,不元素之间的连接权是不
的。6-2 b)络,到,
是一二维矩阵,因此它的征我们可认为是二维的,这些层节点组成的
维矩阵我们称为特征图(feature map,特征图里的每一个元素,都只与输入图像
上的小块区域连接,并且,特征里的不同素的连接值是相等,这些
同的连接权值我们称之为卷积核(convlution kernel。图6-2 b)仅是一张特征图,
实际中的卷积神经网络,往往通过多个不同的卷积核,卷积出多张特征图。
- 58 -
哈尔滨工业大学本科毕业设计(论文)
6.2 卷积神经网络的前馈
层、层,
关于各层细节以及作用们将在后面的小节叙述,现在让我们先大致解卷
积神经网络的结构。如图6-3所示是卷积神经网络其网络构型
6-3 卷积神经网络网络构型
在这结构中,卷层与采样交错现,在网络端采用全接神经网
或其他分类器。图中卷积层里的每一张特征图,其执行过程都如图6-2 b)所示,
些不的特征图应着不同卷积核,多特征图,增加了络的连接目,但
由于张特征图对应一个积核,所以络的参数(即卷核)的数目相比
全连接神经网络参数的数目而言是很小的。
6.2.1 卷积
卷积神经网络所使用的卷积即二维离散卷积,其定义为
y[s, t] =
m
1
+m
2
1
i=1
n
1
+n
2
1
j=1
x[i, j] · k[s i + 1, t j + 1]
1 s m
1
+ m
2
1
1 t n
1
+ n
2
1
(6-1)
中,xm
1
× n
1
阵,据,x[i, j]xi j素。
km
2
× n
2
阵,核,k [i, j]ki j素。y(m
1
+ m
2
1) × (n
1
+ n
2
1)矩阵,称为卷积结果,y[i, j]代表y的第i行第 j列元素。如果从
图像上来解释二维离散卷积,卷积层的操作相当于图6-4描述的过程。图中,原
始图像是一张5 × 5像素的数字“4”的二值图像,如果我们定义卷积核为
kernel =
0 0 0
0 2 0
0 0 0
(6-2)
- 59 -
哈尔滨工业大学本科毕业设计(论文)
6-4 卷积神经网络网络构型
那么经过二维离散卷积后,其得到的卷积结果为
y = x kernel =
2 0 2
2 2 2
0 0 2
(6-3)
将卷结果再经过一阶跃函数行非线性变换后,我可以看到,卷积层通
(6-2)中定义的卷积核对原始图像(即数字4)进行卷积后,其非线性化后的结果
依然保留着数字4的特征。由于卷积核是固定的,因此卷积操作经常被认为是一种
滤波,即用卷积核去检测特征,将这些特征提取出来。
6-4只是利用一个卷积核对原始图片进行卷积得到一张特征图,事实上,正
如图6-3所示,如果我们利用多个卷积核对原始图像进行卷积,那么便可以得到多
张特图。多张特图,意味着可以取到原始像的多个征,例如在手写
字识中,我们提了三张特图,其中一张特图表明左角有一点,一张
征图明右上角有一折线,剩下的一特征图表明右角有一个点,那么通
这三张特征图,我们就可以判定这个数字是7。特征图的作用,在于降低数
的冗余信息,例如“7”这个数字中,横线事实上只需要两个点就可以确定一条直
线,竖线也理只需要两点便可确定一直线,然而横线与竖线之间存在一个
对位移,因此折线的作用便是刻画相对位移的。
6-4中的例子只针对与原始输入数据是一张图像的情况,实际上,卷积操作
应该泛化到输入图像为多张的情况。例如,图6-3中的第二个卷积层,其输入图像
便是张图像。实中,输入图像也太可能是张图像,一张输图像的情
往往出现于灰图像中。然在彩色图中,我们知道,彩色图是具有三
矩阵的,分别代表红R绿G蓝(B。对于输入图像为多张的情况,解决
- 60 -
哈尔滨工业大学本科毕业设计(论文)
的方有两种。一种是利同一卷积去卷积所n输入像,将得到n
卷积结果进行相加合并成为一张,在将它进行非线性映射,从而得到一张特征图,
这个过程如图6-5所示。
6-5 使用同一卷积核卷积多张图像
另外一种解决方法是,假设我们有m张输入特征图,而我们想要卷积后得到n
张输出特征图,那么我们使用m × n 个卷积核,令k
i, j
代表从第i张输入特征图映射
j使核,b
j
j
征图所要加上的偏置,那么卷积操作就可以描述为
M
1
, M
2
, ··· , M
m
k
1,1
k
1,2
, ··· , k
1,n
k
2,1
k
2,2
, ··· , k
2,n
.
.
.
.
.
.
.
.
.
.
.
.
k
m,1
k
m,2
, ··· , k
m,n
b
1
, b
2
, ··· , b
n
=
M
1
, M
2
, ··· , M
n
(6-4)
中,
M
i
m
i=1
m图,
M
j
n
j=1
n果,
法,算,似,
时,矩阵乘法执行的是乘法操作,执行的是卷积操作。卷积操作完成后,再进
行非线性映射,即可得到张特图。式(6-4)际上似于连接经网络的
向传播,但是不同的是,全连接神经网络中,m × n阵里的每一个元素代表连接
权值,是一个常数,而式(6-4)中,m × n阵里的每一个元素代表一个卷积核,
一个阵。另一个同点于,全接神网络行的乘法,而式(6-4)
行的是卷积。
事实上,第一种解决方案只是第二中解决方案的特例,在第一种解决方案中,
实际上相当于K
m×n
中的每一列都强制相等,即
k
1,1
= k
2,1
= ··· = k
m,1
(6-5)
因此,第一解决案意味着强的正则,或者更强的惩罚,因它强制每
列的积核都相等。但是我个认为,尽管这种法确实能作得很好,但这
- 61 -
哈尔滨工业大学本科毕业设计(论文)
不太理的。例如图像中,三输入像,也就是RGB矩阵,采用一种
待,的。
但我直觉上可感觉到,这种颜色不该同等对待,而区分开来,因此
往后的讨论中,我们只讨论第二种解决方案。
6.2.2 采样
图,层,的,
即各张特图的采样时独互不干扰的,因此采样得的特征图与原始的征图
之间是一对应关系。假设我们使用一个均值采样,对于4 × 4的特征图,
们对其每2 × 2区域内取平均,即
1 1 2 2
1 1 2 2
3 3 4 4
3 3 4 4
1 2
3 4
(6-6)
据,使长。
6 × 6素的原始图片,在经过一3 × 3卷积核进行卷积后,得到的特征图
小为4 × 4,但这只是一张特征图,由于在卷积层中我们往往使用多个卷积核进行
卷积,假设我们设定卷积层的输出特征图总量为50,那么将会有50 ×4 ×4 = 800
节点,而原来的节点只5 × 5 = 25节点,这将会使节点增加了32倍。采样层一
2小,后,
2 × 2,此时的节点仅为50 × 2 × 2 = 200个。
另一面,采层可以抑位移变化,卷积到的征图,在经小区
内的均后,弱化其绝位置,而保了其相对置,需要注的是,这里
位移不仅仅只式距离里位移,还应括图像的缩,旋转等,所以这个
移应理解为广义的位移。
采样的方法除了上面提到的平均采样方案,还有一些别的方案,例如xxx文献
中介了一种自学习采样,即小区域并不是简单的和取平均,而是类似
加权和取平均,这些权值便是所需要习的参数。这两种方并没有孰劣孰
的说法,实上两者都能很的工作,但自学的方法确实是比简单的平均
样好一些,但由于平均采样更简单,所以我们往后的讨论只使用平均采样。
- 62 -
哈尔滨工业大学本科毕业设计(论文)
6.2.3 分类器
原始入数经过多次积采样后,征图的尺不断小,最后将使得
行,时,量。如,
一个原始图片为32 × 32小的图像,经过一个5 × 5大小的卷积核后得28 × 28
特征图,对其进行均值采样,将变14 × 14小的特征图,再5 × 5大小的卷
核卷积,将得到10 × 10 小的特征图,采样后5 × 5小,此时再执行一次卷
后,1 × 1了,1001 × 1
图,便100量。如,
28 × 28像,5 × 5积、样、
积、后,4 × 4图,寸,
行,开,104 × 4图,
10 × 4 × 4 = 160维的列向量。
对于后的向量,即可以直使用类器,也可在这些列量的基础
搭建几层含层后再使用类器,这分类器可以是连接神经网络或支向量
机等,选取个取于设计者意愿。关于分类如何使用,读者以参考前
的章节,在卷积网络最顶层的分类器中,与传统神经网络是相同的。
6.3 卷积神经网络的反馈
卷积经网络的练方法与统神经网的训练方法类似,都是采用反向
播算法,但于卷网络特殊构型,需要对其行一些改动,但者的核心
是相的,即通过后一层的差注入前层中,乘上该层激活数相对于净激
的偏导数得到该层的误差,利用这误差乘上净激相对于输入的偏导即可
得到参数更新的增量。唯一的不同点在于注入的方式不同。
6.3.1 分类器误差传播
由于积神经网中最顶层传统的神网络相同,因此数校正以及反
传播方式是相同的。有一点需要注意的是,如果网络最后一个卷积层(或采样层)
中将特征拉成一个列向量,那么反传播的时候需将列向量还原回特图形
式,例如,如果网中最后阶得到104 × 4大小特征图,前向传播过中会
它们并成一个160列向量,那么反向播过中,需160维的
差列向量还原104 × 4特征形式,此得到的特征图可以看做是误差特
- 63 -
哈尔滨工业大学本科毕业设计(论文)
图。
6.3.2 采样层误差传播
在采层中,如果们使用平采样,由于均采并没有额的参数需
学习,因此需要将后一层播回来的差继续传播回一层即可。由于采样
是对一层局部区域平均,所以在将差传播回前一时,只需要将其尺寸
例,可。
如,一个缩小比例为2的采样层,假设它接收到后一层传播回来的误差特征图尺寸
2 × 2,那么这个误差传播回采样层的前一层将得到4 × 4尺寸的特征图,这个过
程如式(6-7)所示
1 2
3 4
1 1 2 2
1 1 2 2
3 3 4 4
3 3 4 4
(6-7)
Kronecker (也 积) 便
Kronecker积过程,即
δ
conv
= δ
sampling
1
n×n
(6-8)
式中需要注意的是,是直积符号而不是逻辑电路里的异或符号。δ
conv
代表传播
前一层(即卷积层)的误差,δ
sampling
代表后一层网络传播到采样层的误差,1
n×n
一个n × n的单位向量,n的取值等于采样层的缩小比例,例如,如果采样层的缩小
比例是2,则n = 2
6.3.3 卷积层误差传播
与传的全接神经网类似,卷积接收到后层传回来的误后,需
要乘以当前层激活函数相对于净激活的偏导数,得到当前层的误差,即
δ
i
= δ
+1
i
·
f (net
i
)
net
i
(6-9)
图,δ
i
层)i图,
δ
+1
i
代表第 + 1 层传播回来的第i张误差特征图,net
i
代表第i张特征图的净激活。
计算到当层的误差后,通卷积自相关性,用这个误可以计算
积核以及偏置的迭代增量,即
[39]
- 64 -
哈尔滨工业大学本科毕业设计(论文)
J
k
i, j
= rot180
conv
x
1
i
, rot180(δ
j
),
valid
(6-10)
中,rot180(·)180
作,
质,conv作,valid内。置,
其梯度为
[39]
J
b
j
=
u,v
(δ
j
)
uv
(6-11)
获取数的梯度后,对卷积的参数进更新,随后将卷积层误差反向传播
采样层,其公式为
[39]
δ
1
j
= f
(u
j
) conv
δ
j
, rot180
iM
j
k
i j
,
f ull
(6-12)
式中,为面向元素的乘法,full’代表卷积的操作范围是全图卷积。通过以上策
略,对网络进行类似的反向传播,即可对整个网络进行反馈校正。
6.4 本章小结
理,
构。多,1989LeCun
[18]
1998LeCunBengio
积,
行卷
[19]
Lee HonglakAndrew Ng将受兹曼卷积网络
合,Convolutional deep belief networks
[40]
[41]
使络,络,
Krizhevsky等人利用它2012年的ImageNet LSVRC-2010数据集上获得了世界第一
的正率,这种卷网络成为前的主流构。尽管卷积网的变体众多,但
大体思路是类似的,都是基于卷积核对局部特征进行提取。
- 65 -
哈尔滨工业大学本科毕业设计(论文)
7 神经网络的设计技巧
神经络的计技巧众多,这技巧致可分为大类,一类训练前对
据的处理,另一类是训练程中采用一些特殊的训手段。数据预处理的
用在于将原始数据处理成容易训练的数据,加快准则函数的收敛速度,另一方面,
原始数据的降维可以在牺牲较小精度的前提下减少运算量,提高程序的执行效率。
训练过程采用的一些特手段在数学上是没太大意义,甚至有时候是反直
觉的,这些巧是年来科研员积累出的经验,其灵感源一般靠蒙。尽
这些验有时候反而降低网络性能,但大部分情况确实会提高性的,某
些情下,不适用些技巧,网络的练初始阶准则函数法收敛。具体设
过程中,对这些巧,我们应该抱试一试的态,如果在网络使用某个
巧,使得网络性能变好了,那么我们便保留这个技巧,否则如果网络性能变差了,
那么就舍弃这个技巧
1
7.1 数据预处理
据的处理致可几类化、降维、扩容、一化。化的用在
于去数据耦合相关性,降的作用在压缩数据,加快法执行效率,由
法,
节。段,
据,大,使强。
数据持在[0, 1]内,之所以要在个区间内,一方面,在些激活函数,
Sigmoid函数中,如果数据尺度过大,则使得激活函数迅速饱和,从而梯度接近
0,权慢。而较小时,我道,Sigmoid
在原点附是一个近似于线性的函数,在训练的初始段便可让权值获得大的
梯度。一方面,如数据尺度大,有可能导致算机的数溢出,尤其
Sigmoid候,项,
溢出测的程语C++言,这一场难,因它会致你码莫
失败。使溢出言,Python,当时,往使
InfNaN代替,时进的不是数运算,而是号运算,这极大降低
运算速度。
1
但前提是这个技巧被正确使用,即编码正确
- 66 -
哈尔滨工业大学本科毕业设计(论文)
7.1.1 降维
人是种受限于维空间的物,我们只能理三维的而法想象更高维
的事物。事上,人同样法理解二的或一维世界,尽管我们以在脑海
想象维曲面或一维线,但人脑海里这些事物这些不是二维,他们只是
在三维空间中的二维(或一维)流形
2
。一张一百万像素的图片,它总能对应着一
百万空间中的一点,而很张某个类的图片,比如狗图片,将会对应
一百万维空间中的多个点。然而并不是一百万维空间中的任何一点都是狗的图片,
它也可能是猫图片,但是样是狗的片,它会在总会某些共通性,这
共通性,或说特征,使狗这一类片在一百维的空间构成一个形,如
果我能找到这个流形,那我们就可避开一百万维间,直接在低维流形
进行分类。
由于们无法理高维空间,因此们通过一三维空间的二维流形简
叙述这件事,如果我们通过式(7-2)求取三维空间中任何一点的(x, y, z)坐标
α = 1.5π (1 + 2 random) (7-1)
x = α cos α y = 21 random z = α sin α (7-2)
中,random[0, 1]数,
swiss roll图,7-1 本,
现,中,7-1
状。辞,状,
事,的。(7-2)
现,(x, y, z)(α, y)述,
xz都是α的函数,从图像上我们也可以直观的感受到,三维数据是多余的,因
为数据的坐落位置十分有规律。
降维,是同的思想,高的数是带有冗的,如我们能找这些
据的维流形,那么就可以低维空间进行数据处理。这衍出了机器学习
一个流形习。关于流形学我们会做过多介绍,我们在本章中
绍两降维方法,主成分分和多维尺分析。与统计学类似,实际中我
也无法找数据真实的低流形,不的降维方法相于对低维流形的不逼近
方法。如果数据背后确实在一个低流形,而我们的降维法又恰好是这
2
更多有意思的观点可以观看麻省理工学院的《量子力学》公开课
- 67 -
哈尔滨工业大学本科毕业设计(论文)
7-1 Swiss Roll
流形描述,那么维不会引信息的损失,例如,三坐标降到坐标并不
引入差,但实际中我们我并不知道体流形,我们的降维法也不是真实
维度变换方法,所以实际中的降维一定会引入信息的损失,导致分类性能的下降,
相比于降维带来的巨大好—-运算效率的提高,这个性能的下降是可接受的。图
像识别,由生活像其维度以千万记,降维必须的,否则以前的计算
性能无法完成准则函数的收敛。
7.1.1.1 主成分分析
为了单起见,我们只这里讨论何使用主分分析将维空间中的数
降到维空间,但二维空间的结论很易被推广到更维度的情况,因为更
维度空间中的结论与二维空间中的结论是相同的。
个含n2X = [x
(1)
, x
(2)
, ··· , x
(n)
]
T
如图7-2
示是一个含有100个样本的数据集在平面直角坐标系上的分布。
如果我们通过计算得到这些样本点的均值 ¯x,即
¯x =
1
n
n
i=1
x
(i)
(7-3)
正如图7-2中的红点,那么我们总能将所有的点用一组基的线性组合来代替,即
x
(i)
= ¯x + α
1
e
1
+ α
2
e
2
(7-4)
- 68 -
哈尔滨工业大学本科毕业设计(论文)
7-2 二维空间中的数据样本点
中,e
1
e
2
量, 7-2 绿
向。
e
1
e
2
为基的二维坐标系,为了降维,我们必然需要舍弃一个维度,这个维度可
能是e
1
e
2
,然而选取哪个维度更好呢 觉上我们会认为选e
2
会更好,因为当
所有的数据点都投影到这个基上时,相比于e
1
能更好地保留数据的信息。
而,e
1
e
2
量,
要比e
1
更好的保留原始数据的特征,假设最优的基向量为e那么为了刻画数据降
维后原始数据与降维后数据的差异性,我们引入一个准则函数
J(α
1
, α
2
, ··· , α
n
) =
n
i=1
( ¯x + α
i
e) x
(i)

( ¯x + α
i
e) x
(i)
T
(7-5)
中, ¯x + α
i
e标,
e标。使
悉的范数,这个准则函数实上刻画是原始坐标到影坐标距离的方,也
就是两者究竟相差了多远。为了最小化这个准则函数,我们先对式(7-5)进行展开,
这将得到
J(α
1
, α
2
, ··· , α
n
, e) =
n
i=1
α
2
i
||e||
2
2
n
i=1
α
i
e
T
(x
i
¯x) +
n
i=1
||x
i
¯x||
2
(7-6)
n
i=1
||x
i
¯x||
2
数据关可去,外,e量,
||e||
2
等于1,因此准则函数可以简写为
J(α
1
, α
2
, ··· , α
n
, e) =
n
i=1
α
2
i
2
n
i=1
α
i
e
T
(x
i
¯x) (7-7)
为了最小化这个准则函数,我们对其求偏导,并另导数为0,则
- 69 -
哈尔滨工业大学本科毕业设计(论文)
∂α
i
= 2α
i
2e
T
(x
i
¯x) = 0 (7-8)
因此当α
i
= e
T
(x
i
ˆx)准则函数取得最小。这实质上说明,当数据点投影e时使得
则函最小,我们的猜合。将(7-8)(7-7),我便可以去准
函数中的n个变量α
1
, ··· , α
n
,只剩余一个变量e,即
J(e) =
n
i=1
e
T
(x
i
ˆx)(x
i
ˆx)
T
e (7-9)
如果我们记号散布矩阵为
S =
n
i=1
(x
i
ˆx)(x
i
ˆx)
T
(7-10)
则准则函数可以谢伟
J(e) = e
T
S e (7-11)
题,e
T
e = 1
λ,构造拉格朗日函数为
L(e) = e
T
S e + λ(e
T
e 1) (7-12)
对拉格朗日求偏导,并另偏导为0
e
L(e) = 2S e + 2λe = 0 (7-13)
此时说明,当S e = λe时,准则函数最小,而事实上这是矩阵对特征根的定义,因
此为了最小化准则数,基向e当选取为散布矩阵S 特征向量。这个结论
以很易推广到高情况,假设们有nd数据样本,么我总能构造
S k使化,
S 最大的k个特征值所对应的特征向量作为投影基,从而新的k维坐标为
α
i
= e
T
(x
(i)
ˆx) (7-14)
由于征向之间是正的,因此降后的数据各个度是独立的,这
是白的目的,因此主成分析也是一白化方法。有时候我需要将降维后
数据还原原始的维度以测降维后的数据究损失了所烧信息,那么利特征
向量的正交性,有
eα
i
= ee
T
(x
(i)
ˆx) = x
(i)
ˆx (7-15)
此时等号两边同时加上均 ˆx可还原出d维数据。如7-3所示是28 × 28像素的图
像,它共有784维,其原始数据为黑底的图像所示。如果我们使用主成分分析将其
降到20维后再将其还原成784数据,其图像如灰底图像所示,我们可以看到,经
- 70 -
哈尔滨工业大学本科毕业设计(论文)
过降维后还原的数据已变得模糊化,而这些模糊并不会影响我们对字的
识别。
7-3 经过主成分分析降维后还原的数据
7.1.1.2 多维尺度分析
[42]
前,起。
市,京、海、广州、州、滨,
ABCDE替。如果我们以北京为坐标平面的原点,那么剩下的城市
标分别为上海(631.6, 796.4)、广州(103.8, 2029.2)、兰州(1228, 428.1)、哈尔
(265, 1082),将这些城市的坐标描绘在平面直角坐标系上的结果如图7-4 a)所示。
另外,我们可以通过计算得到这五个城市的两两距离如图7-4 b)所示。
a) 城市分布图 b) 城市间两两距离
7-4 五个城市的信息
如果现在我们不再知道各个城市的具体坐标,我们只知道图7-4 b)中两两城市
之间的距离,那么如何通过7-4 b)的信息进行地图的重建,或者说根据距离推
导出各个城市的坐标呢 这就是多维尺度分析所要完成的工作。
先,nX = [x
1
, x
2
, ··· , x
n
]
T
i和城市 j之间的欧式距离的平方为
- 71 -
哈尔滨工业大学本科毕业设计(论文)
s
i j
= (x
i
x
j
)
T
(x
i
, x
j
) (7-16)
s
i j
一个n × nS
n×n
这个阵,如
Gram矩阵为
G
n×n
= HXX
T
H (7-17)
其中,H为去中心化矩阵,定义为
H = I
n
ee
T
(7-18)
其中,I
n
n阶单位矩阵,e =
1
n
(1, ··· , 1)
T
,那么Gram矩阵可以推导为
G
n×n
= HXX
T
H =
(x ¯x)
T
(x ¯x)
(7-19)
式中, ¯xX的均值,通过式(7-19),进一步可以推导得
G
n×n
=
1
2
HS H (7-20)
由于欧几里得距离是正定的,因此Gram矩阵也是正定的,如果我们将Gram矩阵特
征分解,则有
G
n×n
= PΣP
T
(7-21)
式中,ΣGram矩阵特征值构成的对角矩阵
Σ =
λ
1
.
.
.
λ
n
(7-22)
PGram阵,P = [p
1
, ··· , p
n
]Gram
最大的k个特征值以及其对应的特征向量,那么通过
ˆ
X =
λ
1
.
.
.
λ
k
[p
1
, ··· , p
k
] (7-23)
我们将得到含有nk维向量的矩阵
ˆ
X,这个矩阵
ˆ
X就是Xk空间的一个映射。
如,在我们地图重构的问题中,通过图7-4 b)中的距离信息,当k = 2时,我们求得
ˆ
X =
45.6 434
677.1 362.1
149.3 1594.9
1182.5 6.2
310.5 1516.5
(7-24)
- 72 -
哈尔滨工业大学本科毕业设计(论文)
如果将上述求得的坐标描绘在平面直角坐标系上,其结果如图7-5 a)所示。我
们可看到,这些与真实分十分相似,只相一个水平像,我们将其镜
后的结果如图7-5 b)示。镜像结果显示,重构的地图中,各个城市所在的相对位
置与实地图中市的相对置相同,但不同的是,在重的地图中,绝对
置改变了,例如我们可以看到,原来处于原点位置的北京现在不在处于原点。
a) 重构后得到的直接结果 b) 镜像后的结果
7-5 多维尺度分析对地图的重构
地图构的例子没有展现多维尺度析是如何降维的,因为这里只是
标。使
得距对于高维空间可复用的,因此于多维尺度分的降维,我们先通过
维空中的数据点两求距离,得到平距离矩阵,在通过这平方距离矩阵
Gram矩阵,将Gram矩阵特征分解,选取最大的k特征值以及对应的特征向量,
们可据降k据。例如,7-6空间
数据降到二维空间的过程。
a) 三维空间中的原始数据 b) 降到二维空间后的数据
7-6 多维尺度分析的降维
- 73 -
哈尔滨工业大学本科毕业设计(论文)
多维度分析并是一个应非常广泛降维方法,其主原因在于欧几
得距离,如图7-7三维空间中AB点,如果使用欧几里得距离(图中的绿线),那
么我认为这两点是分接近的,因此到二维空间后两点将会靠得近。但
实上AB相距远,它两者间经很长流形(图中线)
几里得距离忽视了这种距离。
7-7 Swiss Roll
尽管维尺度分并不常用,但是过它可以入流形学中的一些经典
法,例如Isomap等,用以解决图7-7中类似的情况,更多的讨论可参考文献xxxx
7.1.2 扩容
机器习业内有个共识,很多时别人的分性能比你好并不意味着
的算比你的好,更大的可是他拥有你更多的数据。数据统计机器学习
命脉,没有据,再好的型也难以效。如果把机器习中的算比作是航
器的擎,那么数就是航天的燃料。这种现在深度学中尤为明显,特
是卷神经网络。深度学习要大量的据样本,这个需求量着识别任务复
性的加而增加。尽管互联的大数据代数据容易获取,但些时候数据是
限的,对于限的据集,我们可以过一定的段将数据的容量扩大。例
在字识别务中,们知道,字微量扭曲、旋转、大、缩小对而言
- 74 -
哈尔滨工业大学本科毕业设计(论文)
不会响字符的识别,因此,们可以对原始据进行随机地取上述一个或
个变换,使得数据的容量增大
[43]
。又例如,真实生活中的图片,水平镜像、对
度微调、饱度微调等操作人而言不响最终的图像别,我们利用这个特
对图采取一定的变便可很大度地增大训练的容量,例如,仅仅是图像
水平镜像就可以使得数据集扩大一倍。
数据扩容,实质是一种贝斯先验,因我们数据采取变换策略
会影最终分类,例如,我们会对符进行镜处理。这种验,使得模
可以免疫定的干扰,例如采取了水位移变换策略数据集受到水平位的影
响就减小了,这就提高了模型的泛化能力。
7.2 训练技巧
网络训练程中,我们会使到一技巧,这些巧大部分目的都在
抑制络的过拟合以防止准则数陷入局部最解。由于这些技巧众多,我
无法这里涵盖所有,因此们只挑选几个常用且重的技巧,分别是学习
的设定、动量项的使用以及权衰减。
7.2.1 学习率
在梯度下降算法中,每次求得准则函数相对于参数的梯度J/∂θ后,我们并不
是直接以这个值作为参数的增量,工程中,我们还应对梯度乘上一个学习率η,即
参数更新的公式为
θ = θ η
J
∂θ
(7-25)
学习率的作用类似于下山时步伐的长度,步伐过长,则有可能导致准则函数震荡,
度,大,象,数,
存在一极值点,大的学习也会使其散。例如,假设准则函设定为二
函数,即
J(θ) = θ
2
(7-26)
显然这是一个凸函数,存在唯一极值点,θ = 0处。如果我们对这个准则函数
偏导,则为
J
∂θ
= 2θ (7-27)
J(θ)θ2θθ = 2
4时,η
= 0.52 0.5 × 4
- 75 -
哈尔滨工业大学本科毕业设计(论文)
使θθ = 0处,7-8 a)示。
大, η = 0.7θ沿2 0.8
0.32 0.128 ···轨迹降,如7-8 b)所示。我们习率一些,
η时,η = 1时,θ+22置,
7-8 c)示。率,η = 1.5θ沿
2 4 8 16动,此函数便散,这个7-8 d)
示。
a) η = 0.5 b) η = 0.7
c) η = 1 d) η = 1.5
7-8 不同的学习率对收敛的影响
但是大的习率并不味着一无处,学习率微大些,可以加快收
速度,而且以越过一些局极小值(但是对高尔夫球场形的局部极小值
能为力)。在工程中,学习率的选取我们的建议是,先将学习率初始化为一个较大
的数值,如果准则函数发散了,那么我们就将其缩小2倍,直到准侧函数能开始下
降为止。另一种法是,先初步计梯度的数大小,将学习率定为一个
梯度3数量的常数,例如,我们面的计算到的度是4那么习率
以设定为0.001
- 76 -
哈尔滨工业大学本科毕业设计(论文)
事实学习率固为一个常并不是一较好的策略,因初始时设定的
的,荡。
一种解决法是将学习率设定为一个学习参数,这参数随着网络的训而不
断地新,另外一种虽然愚但行之有的方法是,不断地关准则函数的下
情况,一旦感觉下降开始出现震荡或平谷现象就将学习率调小1个数量级。
7.2.2 动量项
很多候,在数校正的程中,仅使用学率是行的,一般应使
动量项。动量项,即在参数的更新过程中,引入一个动量因子,更新规则描述为
θ
t+1
= θ
t
η(1 p)
J(θ)
∂θ
t
p (θ
t1
θ
t2
) (7-28)
中,t t新,η率, p子,
p = 0.9。式(7-28)际上讲述了这样一件事参数更新的时候,增量不仅仅依赖
于当前的梯度,还依赖于上一次权值变化量的p倍,因此参数的更新,带着类似于
物理中动量的项,即p (θ
t1
θ
t2
),它也被称之为动量项。动量可以使得准则
函数速地下降,并且可以过一些较平坦的局部极值。如读者有数字信
处理的背景,式(7-28)实际上是一个脉冲响应低通滤波器,目的在于平滑参数的更
新过程
[3]
由于(7-28)录上参数量,这在编码一定存,
而且实现起来也不方便,另外一种关于动量项的简单用法是
θ
t+1
= pθ
t
η
J(θ)
∂θ
t
(7-29)
中,p数,一0.9项的使用,以在
局部最优解,例如,假设准则函数为
J(θ) = 5θ
3
80θ
2
400θ 700 (7-30)
我们可以很容易地计算准则函数在任意一点的梯度为
J(θ)
∂θ
= 15θ
2
160θ 400 (7-31)
假设学习率设置为常数0.001,如果不采用动量项,即参数更新的规律为
θ = θ 0.001
J(θ)
∂θ
(7-32)
那么准则函数的收敛过程如7-9 a)所示,我们可以看到,在收敛的后半阶段,参
θ值,使0.9项,
则为
- 77 -
哈尔滨工业大学本科毕业设计(论文)
θ = 0.9 θ 0.001
J(θ)
∂θ
(7-33)
此时的准则函数收敛过程如图7-9 b)所示,我们可以看到,动量项的引入,使得
θ在平坦的局部极值区域内依然带有冲劲,这个性质使得它可以跨越一些较小的
局部极值而不至于陷入其中。
a) 不使用动量项 b) 使用系数为0.9的动量项
7-9 动量项对收敛的影响
7.2.3 权衰减
减,1ee
般取0.999右。之所以要这样做的原因,是因为我们希望权值保持在较小的范围
内,因为更的权值使得净活停留在活函数的非饱区域内。使用权衰减
参数更新规则为
θ = e θ (7-34)
关于衰减的另种解释是,准则函数中,我加入一个范数惩罚,即新
准则函数定义为
J
new
(θ) = J(θ) +
λ
2
θ
T
θ (7-35)
(7-35)中的第二项也被称为正则项。如果我们对式(7-35)求导,则为
J
new
(θ)
∂θ
=
J(θ)
∂θ
+ λθ (7-36)
因此权值的更新规则为
θ = θ
J
new
(θ)
∂θ
=
θ
J(θ)
∂θ
λθ (7-37)
实上7-34,即新后系数。所以
使用权衰减,或者说加入二范数正则(这两个命题等价),实际上它代表着一种贝
- 78 -
哈尔滨工业大学本科毕业设计(论文)
叶斯先验,即我们对于权值的期待(希望它是较小的值)
需要意的是,在神经网中,我一般只针权值行权减,而不针
偏置行权衰减,为我们希获得较大偏置。至于为什么,这际上并没
为什么。
7.3 编码技巧
尽管们讨论了量的理论容,这些理论内具体实现代码上并不是
件简的事。代码如何设计及如何测是我们遇到的大问题。与传统的软
工程不同的是,机器学习的测试无使用单元测试,因为单元测试中我
需要知道码的期望输出,机器学习学习的特点注了我们无法知道其确输
出是么。代码的试,更多时是凭觉,尽管如此,我还是办法进行
些简测试的,在本小节中,们将会介绍面对象的设计思以及用于测试
梯度校验。
7.3.1 面向对象技术
神经络的计中,不同层可采用同的激活数,也可以用不同的
络结构,例卷积或全连接层。这不同层之都有两个同的特性。在前
传播程中,无论是什么形的层都接前一层传播的活,而在反向传播过
中,所有的都接收后一层播回来的差,并利用该层的输与输出对参数
行校正。尽不同结构的网层其校正式不同,但这个过程以使用面向对
的技术实现。为了方便讨论,我们将用JAVA的语法来描述这个过程
3
。我们定义一
Layer法,fpropbprop
播。fprop接收一个参数,即前向传播得到的输入数据,bprop接收三个参数,分别
是反向传播回来的误差、该层的输入以及该层的输出,事实上,bprop可以设定
为只收一个参数,即反向播回来的差,而该层的输入以该层的输出设
量。具体构,ConvlutionLayerFullConnectLayer
个接口,并现这接口中的个方法,利用多性,就可以容易实现不同
执行同的更新方法。如果络的所有都采用同一个活函数,那么这个激
函数可以直接写到接口中(尽管JAVAJDK9中才能在接口中提供方法的实现,但
我们可以利用继承让具体的层继承另一个类)如果网络的所有层采用的是不同的
激活数,那么我们可以通策略模式激活函数抽象一个接口,具体的激
3
然而JAVA并不是一门适合数值运算的语言
- 79 -
哈尔滨工业大学本科毕业设计(论文)
函数实现个接口,在具体网络层实类的构造方法通过依赖注入将具的激
活函实现注入到网层的类中,利用态性,可以让不同的执行不同的激
函数,而这不同的激活函又可以实代码复用。最后将这不同的网络层
中,CNNDBN作,
整个工程代码的UML图如图7-10所示。
7-10 神经网络类图设计
7.3.2 梯度校验
中,
码。很多时候,错误的编码并不会导致严重的错误,但它会影响最终的分类效果。
debug过程中,一个十分有效的用来检测编码是否正确的方法是梯度校验。假设
们要θ参数则函数,梯度中,我的更则如(7-25)
示。假设我通过法计算得准则函数对于参数梯度,例如,在全连接
经网路中,这个梯度一般为
J(θ)
∂θ
= δ ·
f (net)
net
net
θ
(7-38)
(7-38)本质上是利用导数公式取计算梯度,正如我们要J(θ) = θ
2
的导数,那
我们以通过其数即J
= 2θ 计算在某处的导数,但我还可以通另一
数。义,限,
定义为
J(θ)
∂θ
= lim
θ0
J(θ + θ) J(θ)
θ
(7-39)
就是说,如们给个参θ
i
上一非常的增θ,假0.001,那
(7-39)理,我θ
i
前准J(θ)上增
- 80 -
哈尔滨工业大学本科毕业设计(论文)
值,差,量,θ
i
量的梯度。这种方法求得的梯度
θ
J(θ)与利用式(7-38)
θ
J(θ)满足如下关系
θ
J(θ)
θ
J(θ) (7-40)
如果θ取得足够小,那么这两者近似程度非常高,但是实际编码中θ不应
得过小,因为计算机的浮点运算会带来误差,一般而言,θ0.001左右就足以用
来验梯度了。另需要注意是,这种近似性会在较深层中发生,在较
的层误差会较大,因为反向播是贪婪的,所随着误差传越远,梯度的
离也越大。利用梯度校验可以方便验代码正确性同时,还可以在梯度
验的过程总发现,如果激活函数Sigmoid函数,而网络有是深度网络,那么不
过预训练的网络会出现梯度消失现象。
7.4 本章小结
本章我们讨论神经网络练过程中些会使用到的巧,我们只介绍
一些用的技巧,多的特殊巧如dropoutmaxout等我们并有讨论,更多的
[44][45]本章中,题,
并不仅作为技巧而在,它是机器学的一个分支,我们只绍了两种降维
式,更降维Isomap、局线性入、基的主分分可参
[46–48]。最后还需要说明一点,网络的设计者不应迷信这些技巧,它们只是
到指导作用,具体是否可行要具体任务具体分析。
- 81 -
哈尔滨工业大学本科毕业设计(论文)
8 GPU计算
上世六十年代出的摩尔律到目前止已经持续了个多世纪,硅技
似乎经难以再有重突破,摩尔定律未来几年或将为过去。然而当前计
机的计算力仍不足以满人们的需求,并行技术的展在一定程度上缓了这
种压力,某种程度上而言,计算并行化可以看做是摩尔定律的一种延伸。
GPUGraphic Processing Unit)又称“图形处理器”,是相对于CPU的一个
念,时、
求。中,的,
GPU的设计者而言,他们更倾向于添加更多的核心而不是提高核心的运行效率,
通过个核心以线程技术,使得同一条令可在每元素上执行。此外,他
CPU件,GPU算,
CPU更适用于含有复杂流控的计算。
GPU台,言,
使GPU事。此,ATI(已AMD购)
2005ATI Stream案,NVIDIA2007CUDA台,
GPU力。GPU时,
出,Apple 2008 OpenCLOpen Computing
Language)规范,微软DirectCopmute规范,的都制定API
并在此基础上开发GPU通用计算软件。
GPGPUGeneral Purpose GPU中,CUDA
一个类似于C的编程环境,使用者可以快速学习,所以受到了广泛的使用。
8.1 GPU体系结构
CPU 言, GPU 的,
势。 CPU 慢,
时, GPU 展, CPU
IntelCPUNVIDIAGPU 比。
CPU言,GPU其设则就对密算的,在浮算上
天优势。几年CPU率上缓慢,此同时,GPU算却
展,其运算性能已远远超过CPU。如图8-1所示是IntelCPUNVIDIAGPU在各
- 82 -
哈尔滨工业大学本科毕业设计(论文)
个型号上每秒浮点运算量的对比
1
8-1 GPU CPU在每秒浮点运算量上的差异
GPU元,CPU同。
典型的CPU结构带有三级缓存,数据由内存经过三层缓存后才进入到处理器核心,
个结所示。GPU带有存,这个一般级,与CPU
是,CPU个处器,GPU中并理器的概念,而代
流处理器簇Streaming Muntiprocessor在一个GPU中往往含有多个流处理器簇,
管它CPU理器有着的差异,但某度上以看GPU
核心,整个GPU的结构如图所示。
a) CPU结构 b) GPU结构
8-2 CPUGPU结构差异
CPU术,CPU心,Intel
1
图片出自于NVIDIA的官方技术文档《CUDA C Programming Guide
- 83 -
哈尔滨工业大学本科毕业设计(论文)
i7 4CPU 心, 使 CPU 算,
GPU言,CPU的。100
量的每一个元素乘上一个常2,那么对4核的CPU,我们可以指派1CPU
125个元的操作,2CPU执行2650元素的操作,但对GPU言,它
可以直接开辟100个线程,每个线程针对每个元素进行操作,这些线程是并行线程
而不是并发线程,因此GPU可以实现小粒度的并行。
GPU线GPU列,
成,GPU16
CUDA心,如,
GPU48CUDA心,GPU
器簇192CUDA心。这些核并不类似CPU核心,CPU的每核心
能执行一个线程,而CUDA核心可以并行执行多个线程。
GPU的线由线网格理,线网格以看是一二维格,这个结
如图8-3所示。在这个网格中,一个维度是线程块,另一个是线程束。每个GPU
最多包含65536线块,每线程最多512个线束,这味着
们可一次辟最多大3300个线程,目前的米架已经实现个线程块
1024个线束,因它最可开6600线程。这只说我以在
码中辟线程,并意味着执线程也是个数量级。事实上,每流处理器
可执行的线程数量是有限制的,这个数量级大约是一千左右。
8-3 线程网格
实际在跑的线数大约为万,然而我们却以在代码开辟几千万的线
程,这GPU对硬的隐制,类于操系统拟地址,GPU会自
地将这几万的虚拟线程几万实际线程中调度,而序员不需要参与到个过
- 84 -
哈尔滨工业大学本科毕业设计(论文)
程中,只需在代中开辟线即可。这个机制使得硬件升扩展变得单,因
为虚的线与实际调的线程是离的,GPU为我自动调度,们可以随
的更换未来更多核心的GPU而不需要改动我们的代码。
为了好地解线块与线程的念,我举一GPU中实两个量相
的例子,如代码8.1所示
代码 8.1 向量加法内核函数
1 g l o b a l vo id add ( i n t c , i n t a , i n t b ) {
2 i n t t i d = b l o c k I d . x ;
3 c [ t i d ] = a [ t i d ] + b [ t i d ] ;
4 }
8.1的的 kernel GPU中执码,们称
核函数。由 kernel 记的代码将nvcc译器编译,而没有这个标记的函数
C++器编
2
2行代线号,这线
线程的编号,即默认每个线程块只有个线程在运行。如果个线程块有多
个线程在执行,那么第2行代码应改为
i n t t i d = t h r e a d I d x . x + b l o c k I d . x + blockDim . x ;
观察图8-3,这实质上类似于二维索引空间转换为线性空间的代码。代码8.1
3线作,atidb
tid加,ctid中。为,8.1
线程,线后,线ID
(即tid)执行向量a和向量b中的第tid的元素的操作。
8.2 CUDA
CUDACompute Unified Device Architecture)是NVIDIA公司在2007年推出的
高性运算台,它可以GPU在执常规的图渲染基础上额地实现高
算。CUDACUDAGPU
擎,通GPU 的处力,可提升能。支CUDA台的GPU
NVIDIA Tesla NVIDIA Quadro 以及NVIDIA GeForce多个系列,其价格也涵盖
场,使CUDA
2
例如Windows操作系统下的msvcLinux操作系统下的gcc
- 85 -
哈尔滨工业大学本科毕业设计(论文)
求。止,CUDA理、学、
拟、析、域,700
CUDAGPU群,佛龙
的法国巴黎银行等。
CUDA中, GPU中,
GPU内存的回收,例如,为了执行两个向量的加法,其片段如代码8.2所示
代码 8.2 GPU 中向量加法的调用过程
1 i n t a [N] , b [N] , c [N ] ;
2 i n t d e v a , d e v b , d e v c ;
3 / / i n i t a [N ] , b [N ] . . . . .
4 c u d a Ma ll oc ( ( v oi d )& de v a , N s i z e o f ( i n t ) ) ;
5 c u d a Ma ll oc ( ( v oi d )& d e v b , N s i z e o f ( i n t ) ) ;
6 c u d a Ma ll oc ( ( v oi d )& de v c , N s i z e o f ( i n t ) ) ;
7 cudaMemcpy ( d ev a , a , N s i z e o f ( i n t ) , cudaMemcpyHostToDevice ) ;
8 cudaMemcpy ( dev b , b , N s i z e o f ( i n t ) , cudaMemcpyHostToDevice ) ;
9 add <<<N, 1>>>( dev c , de v a , d e v a ) ;
10 cudaMemcpy ( c , de v c , N s i z e o f ( i n t ) , cudaMemcpyDeviceToHost ) ;
11 c u d a F r e e ( d e v a ) ;
12 c u d a F r e e ( d ev b ) ;
13 c u d a F r e e ( d e v c ) ;
在代码8.2中,我们先在GPU中申请内存,即对应的46行,随后在78行中将
GPU中。98.1
函数,GPU中开N个线程块,每个线程块含1个线程,GPU成计后,我
10GPU存,1113
存。释放内是重的,如果申请了存不释放便会导致内泄露,当内存消
完毕后程序崩溃。
我们由感叹,为执行一个单的量加法就编写此多的代码,我
需要工申内存,工将据迁GPU中,手调用核函数,调完毕
需要工将算结GPU中迁移回来,最后需要手工放申的内存。如
的程员,困难。此,CUDA
多个团队机器学习研究员开发了专门的第方库,我们将会介绍几个见的
包。
- 86 -
哈尔滨工业大学本科毕业设计(论文)
8.3 Cudamat
CudamatPython
[49]
基于CUDA实现GPU算的保留Python“语法优雅”特性,
使便Python库。Cudamat
便模,使CUDA来,
GPU 势,
Cudamat相对于numpyMATLAB,其运算速度大约提升了50倍左右。
Cudamat中,符,使
运算及面向元素的则运算,以及矩的切片、转置等操作再需要编写大
的代或调用对的函数。此外,开者还提供一些常用函数,例如面向
素的exp()log()sqrt()pow(),矩阵的乘法以及面向轴的求和、随机矩阵的生成
等。例如,为了实现一个logistic函数,只需要在Python中只书写代码8.3中的语句
代码 8.3 Cudamatlogistic的实现
d e f l o g i s t i c (A ) :
expTerm = cudamat . CUDAMatrix ( numpy . random . r a n d n (A . s ha p e ) )
cm . exp ( A, t a r g e t =expTerm )
r e t u r n 1 / ( 1 + expTerm )
尽管Cudamat并没有CUDA所有功能都囊括其中,但在机器学习中常用
基本了,所有不需CUDA地建
数学模型的代码,减轻了我们的工作量。
8.4 Gnumpy
Python 中, numpyscipy 色,
numpy凭借美的现以地执深受爱。在numpy中,
计,广性、片、便取、等。
MATLAB近,MATLABnumpy
应的现,此还加一些MATLAB所不持的能,例方便嵌入C++
码、便地像、IO能。numpy语法单,C
但由本质还是CPU的运算,所在大模的算中行效显得
难尽人意。
- 87 -
哈尔滨工业大学本科毕业设计(论文)
Cudamat使CUDA便多,
层,GPU放,
数,然而,Cudamatnumpy代码少,如代8.3exp需要
在参列表中带上返变量,而这个返变量又必须要声明,无法实现变量
态使用,所以Cudamat明显C风格,违背Python于“简就是
美”的设计原则。鉴于以上原因,多伦多大学在cudamat基础上开发了新一代
源第方包—Gnumpy
[50]
Gnumpy计算GPU计算,其接特性
numpyGnumpyCudamat的,GnumpyCudamat
子,者已了,numpy便接口。
如,同样是实现logistic函数,在Gnumpy中只需写成代码8.4中的形式
代码 8.4 Gnumpylogistic的实现
d e f l o g i s t i c (A ) :
r e t u r n 1 / ( 1 + gnumpy . exp ( A ) )
事实上,gnumpy已经为我们实现了logistic数,因此我们只需要一条语句
可完成该功能
A . l o g i s t i c ( )
使 Gnumpy 序, Cudamat 短,
试, numpy使 手。
Gnumpy Cudamat 发,
Cudamat,因此使用者无需过于担心效率问题。
8.5 PyCUDA
GnumpyCudamat作,
作,积。
CUDA C码,PyCUDA库。
PyCUDAAndreas KlocknerNicolas PintoPython
[51]
PythonCUDA C码。PyCUDA中,
数, 码。 时,Python
CUDACUDA C件,
Python这个数。如,为乘的数,码如
代码8.5所示
- 88 -
哈尔滨工业大学本科毕业设计(论文)
代码 8.5 Pycuda中实现向量相加
1 i mport py c u d a . d r i v e r a s GPU
2 from py c u d a . c o m p i l e r im port So u r ceModul e
3 d e f add (A, B , N ) :
4 code = S o u r c e Modul e (
5 g l o b a l v o i d add ( i n t c , i n t a , i n t b ) {
6 i n t t i d = b l o c k I d . x ;
7 c [ t i d ] = a [ t i d ] + b [ t i d ] ;
8 }
9 )
10 a ddB yGP U = c o d e . g e t f u n c t i o n ( add )
11 C = numpy . z e r o s l i k e (A)
12 a ddB yGP U (GPU . Out (C ) , GPU . I n (A) , GPU . I n ( B ) ,
13 b l o c k =(N, 1 , 1 ) , g r i d = ( 1 , 1 ) )
14 r e t u r n C
代码8.5的第49行通过字符串的形式嵌入CUDA C的内核函数,第10行试图去
add数,行,
过字串形式嵌了“add这个函数,Python就会调用nvcc译器代码
行编译,并存为动态链接件,当下一次再图获取这个内函数时不需要
编译一次而直接调用。第12行执行GPU中的计算,以AB作为输入,C作为输出,
执行在N个线程块上。最后返回运算结果C
PyCUDA使码自高,我现任想要
数。使杂。餐,
选择一个自由度高的库或是选择一个代码简单的库完全取决于你的权衡。
8.6 Cae
Python库,
能,法。
验,现,Cae
择。CaeJia Yangqing
CUDA
[52]
C++/CUDA现,
PythonMATLAB口,并且通过执行。Cae中,开发
- 89 -
哈尔滨工业大学本科毕业设计(论文)
写好种各样的络层的代码,如全连接层、卷层等。使用者无编写具体
代码,Cae让深度学习的研究人员从具体的代码中解放出来,我们只需要将自己
设计的网络模型写成配置文件即可。如代码8.6一个神经网络的配置文件中的一
个片段
代码 8.6 神经网络配置文件片段
1 l a y e r s {
2 name : p o o l 1
3 t y p e : POOLING
4 b o tto m : conv1
5 t o p : p o o l 1
6 p o o l i n g p a r a m {
7 p o o l : MAX
8 k e r n e l s i z e : 3
9 s t r i d e : 2
10 }
11 }
8.6中,层。成,
25义,610义。2字,3
义了的类型,4行定义了层网的前层网络的字,第5义了后一
(这身)7使样,
8行定义了卷积核的尺寸为3 × 3,第9行定义了卷积间隔为2
8.7 本章小结
章中,绍了GPU算,于本一个GPU南,因
仅限简单绍,更关于CUDA C的编南可考文[53][54]在本
段,CUDA库,取,
如果需要编写的代码只含有简单的矩阵操作,那么我们推荐使用Gnumpy库,如果
代码含有一些很复的矩阵操作,而些操作又是可行的,那么我们推荐使
PyCUDA个库以用网络可以的机算法
上,码。
如果工作的内容只涉及神经网络,而又不想编写代码,那么我们推荐使用Cae
- 90 -
哈尔滨工业大学本科毕业设计(论文)
9 实验现象及讨论
我们MNIST数据上分别实现了深度置信络与卷积神经网络,使用深度
98.72% 率,使
98.9%率。CIFAR-10络,
62%的正确率,此外,通Cae测试了由xxx提出的网络构型的学习效果,并将
其与我们的网络学习效果进行对比。
9.1 数据集简介
MNISTCIFAR-10是学术界两个重要的数据集,这两个数据集一般作为标准
数据而存在,每人们提出种新的算法,都用这两个据集做验证,下
我们将简单介绍这两个数据集。
9.1.1 MNIST
MNIST数据集是一个真实世界中采集的手写数字图像数据集
[55]
,它由NIST
议收集并持有,读者可到MNIST主页免费获取该数据集。这个数据集一共含有4
文件,别存训练据、训练标签、测试据、测试标签。文以二制文
储,像。
60000个样本,测试集含有10000样本,这些样本收集自500位不同的人的手写
字体。
9-1 MNIST数据集部分数据样本
每个据样本是28 × 28素的灰度图像,由于入了抗锯齿效果,所图像
数值范围是0 255而不是二值图像。图像已经经过预处理,因此图像会集中在
- 91 -
哈尔滨工业大学本科毕业设计(论文)
20 × 20区域内,此外,图像的心点与像素点重心重合,所以如果要使
(比k邻,SVM等)
使得数字的几何中心与图像中心重合会改善你的算法性能。
如图9-1MNIST数据集中的一小部分样本的展示,原始的数据应该是黑底白
字的,为了美观,我们将其颜色反转并加上周围的边框。
9.1.2 CIFAR-10
CIFARAlex Krizhevsky, Vinod NairGeorey Hinton
8
[56]
图片注。CIFAR-10
据集个子集,含有50000样本10000试样本,这些经过
10别,机、车、鸟、
[57]
CIFAR-
10的官费获这个据集,包含7件,其5个文是训集,每
文件包含10000个训练样本,1个文件存储测试集,包含10000样本,这些样本
都被机打散,所以不用担类别的出顺序会导致算性能上的差异。剩余
对。CIFAR-10式,
别对PythonMATLAB形式储格式,者可己的
言背景选取其中一种进行下载。
9-2 CIFAR-10数据集部分数据样本
个数本都大小32 × 32色图像,因此图像含三32 ×
32阵,RGB道。9-2
本,到,像,
- 92 -
哈尔滨工业大学本科毕业设计(论文)
MNIST而言,每个类别个体的图像差异较大,而不MNIST中每个类别的个
差异较小,所以在CIFAR-10据集中使用模板匹配的方法进行分类是几乎不可
的。
9.2 深度置信网络在MNIST数据集上的性能
MNIST上,7络,
78462198260041056910,最数是据输
的,即28 × 28 = 784是根的,即10
类别。中间隐含层节点我随意选取,这些点是如此的随以至于源自我
银行卡号。在深度置信网络中,对隐含节点并没有过多的要求,大致合理即可。
整个络可以看5个受限玻兹曼机叠加组成,分别是784621621982
···410569,最后一56910softmax分类器。在整个络的训练程中,
们先依次对其中的5受限尔兹曼机做贪婪训练,即先训784621的受限玻
兹曼机,训练完毕后将所有的样本(60000个)通过这个训练完毕的受限玻尔兹曼
前向播,得60000621的数本,用这些变换的样练下
个,621982机,推。softmax
将其当做一个两层softmax网络进行预训练。
观察受限玻尔兹曼机的权值更新公式(4-43)(4-44)以及(4-45)为了方便大家
观察,我们将这三个公式再书写一次
ln P(v)
w
i, j
P(h
i
= 1|v
(0)
)v
(0)
j
P(h
i
= 1|v
(k)
)v
(k)
j
(9-1)
ln P(v)
b
vi
v
(0)
j
v
(k)
j
(9-2)
ln P(v)
b
i
P(h
i
= 1|v
(0)
) P(h
i
= 1|v
(k)
) (9-3)
这三个公式背后隐藏着一层重构的含义,即对于一个两层的受限玻尔兹曼机,
在第一层数据通过前向播得到第二层的数据,第层的数据反向注入到第
一层数据,数据过这样一迁移,相当于利提取的特重构原始本,因
此在受限尔兹曼机的训过程中,一个刻画其训练况的方法是跟踪其构误
差,如图9-3所示是某一层受限玻尔兹曼机的重构误差下降曲线。
- 93 -
哈尔滨工业大学本科毕业设计(论文)
9-3 受限玻尔兹曼机重构误差下降曲线
从图9-3中我们不难发现,训练的前10个周期重构误差迅速下降,随后的周期
慢,限,可,
但训更多的周期会助于获取好的实验结果。需要到的一点是,在受限
尔兹机的练中,动量是必须的,们在实验发现,不使动量时,在
训练的初始阶段重构误差无法下降。
构,9-4
784621况,
注。是,9-49-1致,
9-10 25501化,使
的方法是,对每个像素点除以255得到一个[0,1]区间的小数p,以数值p为概率将其
1,以1 p概率将其0。另一种01的方法是,直接保留这个小数而不将其
离散化。
9-4 受限玻尔兹曼机对数字的重构
最顶层softmax分类器的训练也是贪婪的,即它只训练56910两层网络之
的参数,在这里,训练周期我们不建太长,一训练510周期即可,否则
- 94 -
哈尔滨工业大学本科毕业设计(论文)
随后的方向传播过程中,如果softmax训练过久,则网络的输出误差较小,没有
播,败,解,
这个局部最优由最顶层的softmax决定而不是整个网络决定。
后,调,
这个过程与传统的神经网络相同,我们不进行过多的叙述,如图9-5所示是整个网
络进行反向传播时的误差下降曲线
9-5 深度置信网络误差下降曲线
现,9-5线
98.72%此,据,
9-5中的数据是前期研究工作中没有遗失的数据,因此这并不是最终的误差下降
曲线。但是我们的实验是可重现的,只需按照我们的结构便可再98.72% 正确
率,由于我的时有限,并没有将个实验重做一遍,感兴趣读者可以
试。
后,字,
9-6中,每个样本下边的黑色数字代表测试集给定的标签,而红色数字代表网络
签。现,中,性,
人也以区分究竟是个数字,而有一分样本人可以容易识别,网络却识
错误,还有部分本数据本就是错误的,根无法识别是哪个数字,这
候我们不能舍弃机器也能将其识别出来。
在整网络训练中,我使用动量项、权减技术,而没有没使用
维技术,因数据度并不是别高,计算机的理能力足应付。如果原始
据的度非常高,比如几百维,那么就需要用一些降维技将原始数据进
压缩。
- 95 -
哈尔滨工业大学本科毕业设计(论文)
9-6 被网络误分类的样本
息,使
200060000本,90
率,后面中的实验中我们会看到,这种策略在卷积神经网络中是行不通的。
9.3 卷积神经网络在MNIST数据集上的性能
MNIST数据集,我们设计了一个6层卷积网络,其网络构型描述如下
128 × 28的原始图像
卷积原始图像得到624 × 24特征图
6张特征图进行采样得到612 × 12特征图
6张特征图进行卷积得到128 × 8特征图
12张特征图进行采样得到124 × 4特征图
此时124 × 4特征图无法再进行卷积,将其展开得到192个节点
192个节点与10个输出节点做全连接网络,与传统神经网络一样
其中,激活函数我们选取的是sigmoid函数,当然这个函数也可以换成ReLU
数,全连接网络我们采用平方误差作为准则,而不是深度置信网络中的softmax
类器。在这网络中,我不采用预练而是直进行全局反向传播。以上
网络构型的选取方案都是随意的,并没有说一定要采用这个方案。
线 9-7 示, 后,
MNIST98.9%率。到,20期,
训练差与测试差迅速下降,随后的周中误差缓下降,到了后期,收敛
分缓慢,但然会下降的趋势。有思的是,对网络练一个很的周期并
- 96 -
哈尔滨工业大学本科毕业设计(论文)
会产明显的过学习象,所以如果你要实现一个高别率的网络,那么你
以放心地等待一段很长的的时间。
是,性,
中,期,动,如,
98.70%后,98.70%动,98.73%
98.74%。然而,在卷积网络中,到98.70%后,它可能一下跌到98.40%然后
又升98.80%,这较大范围的波动,应不是随机梯度成的,因为深度置信
网络中我采取随机梯度新时也没有这么大波动,我们推测这是因为积网
络代表着一种非常强的惩罚(强迫权值共享),惩罚过大导致波动变大。
9-7 卷积神经网络训练误差及测试误差
在实中,我们并有采用权减,因为我发现使用权衰减网络的性
变差。此外,我们发现当改变网络中的一些参数,比如特征图的张数,学习率时,
对网的收敛影响较大,但最终结果没有太大影响。卷积络对样本的需
量非大,实中,我选取2000本作训练对网进行练,网络完
敛,的,60000
训练对网络进行训时,网络才开始敛。我们估计这是因卷积网络的权
共享导致只有通过大量样本才能学习特征,这与板匹配方法有着很的区
别。
网络练完后,我们对测试中的部分数据行观察,第层卷积层
9-8 a)示。0 910本,
个样本。其中,每一行第一张是原始28 × 28像,随六张是卷积出来的
24 × 24征图。9-8 a),我现一象。例如,
原始像是黑底字的,而有些特征图转成为白黑字,又比如,第六张
征图是对图像进行边界检测,为了验证我们这个想法,我们随机选取了“4”这个
- 97 -
哈尔滨工业大学本科毕业设计(论文)
取,9-8 b) 示,察,我
现,对于不同的写法,其提取到的特征都是近似的,它会检测4”的左边竖线的
上方点以及对下来一个折线,右边线的上方一点及下方的一点。另一
有意思的现象是,第三张特征图看起来是一个3D图像,想象图像的左上角有一束
阳光下,当我们出右手,掌贴着前的纸张面,大拇指纸张方,握
拳,数字经我们四个手指方向旋转一定角度后,那么阳洒下的阴影如
第三特征图所示。这个现在第五张征图中也出现了,只第五张特征图
角。手,面,
大拇朝纸张下方,握拳,我可以看到数字过我们四个手的方向旋转过
定角度后,阳光洒下的投影正如第五张特征图所示。
a) 0-9
b) 针对数字“4”提取到的特征
9-8 第一层卷积层抽取得到的特征图
9.4 卷积神经网络在CIFAR-10数据集上的性能
相比MNIST数据集,CIFAR-10数据集的识别更为困难。由于计算资源的限
制,我们只在CIFAR-10设计了一个较小的卷积网络,与MNIST手写数字的卷积
似,CIFAR-10上,4络,
- 98 -
哈尔滨工业大学本科毕业设计(论文)
络构型描述如下
332 × 32的原始图像
卷积原始图像得到928 × 28特征图
9张特征图进行采样得到914 × 14特征图
尽管95 × 5特征图仍然可以被卷积,但我们依然将其展开为1764个节点
1764个节点与10个输出节点做全连接网络,与传统神经网络一样
网络的属性MNIST实验中的相同,激活函数我们依然选sigmoid函数,全
则,
9-9 a)示,测集误差量降如9-9 b)示。需注意的是,看起在图9-9
a)与图9-9 b)中误差下降速度非常快,对比与图9-7,其斜率更大,然而这是一个假
象,因轴进放,事CIFAR差下慢,而
且在训练集与测试集中仍然后很大的误差可以下降。
a) 训练误差下降曲线 b) 测试误差下降曲线
9-9 CIFAR的训练误差与测试误差
因为CIFAR-10据集的复杂性,本应该建立一个庞大的网络进行训练,但
限,迫,络,外,
对网络的训练我们也仅仅训练了400个周期左右,因此,整个网络训练完毕后我们
只得到62%的识别正确率。
9-10本,别,
图中总共包含了10个类别100样本。观察这些样本我们会发现,网络能识别的图
像对移、旋转等质具不敏感性。如,在飞机个类别中,络可以识
头部左、向右等个角度的机,还可以识别仰角不同图片,由于这些
片不具备模板性,所以卷积网络基本没有了模板匹配的缺点。
- 99 -
哈尔滨工业大学本科毕业设计(论文)
9-10 被网络正确识别的CIFAR-10部分样本
跟踪样本,绘制9-11示。每个
样本下方黑色数字代表训练集提供的标签值,而色数字代表网络的出标
签值,标签值于类别名字的键值对可参照图9-1我们发现,在一些样本中,网络
会将大卡错误地识别成汽车或将小汽车错地识别成大卡车,这似乎以原
谅,但有一图像错误识别我们无法谅的,例如将马别成大卡车。这
错误样本中很多样人是可识的,而机器不可识别,我们测这是因为我
大,长,取,
从而影响最终的识别效果。
9-11 被网络错误识别的CIFAR-10部分样本
- 100 -
哈尔滨工业大学本科毕业设计(论文)
能, MNIST 作,
9-12示。“飞机”
9本,本。中,
32 × 32小的RGB道,这三张图像合成第四张32 × 32色图像。随后的九张
是第一层卷积层提取到的九张28 × 28大小的特征图。对比这些原始数据与特征图,
现,的,
息,将的边取出形成图。这特征中,有一特征2张,
8张并没有提取到一些人可理解的特征,我们猜测随着训练周期的增加,这些特
征将会逐渐显露出来,由于时间有限,我们并没有验证我们的猜想。
9-12 针对“飞机”类别提取的特征
这些征图应该以通过选某几张组彩色的特征图,我们并不知道
取哪张合适,所我们没有做这步工作。此外,这些特征表明,在他
之上该再添加一些积层对特继续提取,而不是我设计的全连接络,由
于我们的计算资源十分匮乏,所以我们也没有进一步展开这项工作。
9.5 使用Cae实现的CIFAR-10数据集训练
CIFAR-10决,xxx
现,正确率为91%。另一识别率较高的网络由Alex Krizhevsky等人实现,其识别率
89%,这稍微杂所不会中提及,多的阅读
- 101 -
哈尔滨工业大学本科毕业设计(论文)
其论文[41]。在Cae中的卷积网络构型采取的是Alex Krizhevsky的方案,为了实现
比,我使Cae证了Alex Krizhevsky等人构型CIFAR-10
的训练效果,其训练误差与测试误差曲线如图9-13所示
a) 训练误差下降曲线 b) 测试误差下降曲线
9-13 使用Ca e训练模型得到的误差
由于Cae代码是每100周期训练误差一次测试,500个周期对
试,9-13线滑。到,
动,Alex Krizhevsky使
用了dropout巧,这个技巧会对训集产生一个很大的惩罚,从而导致训练误差
出现波动,然而这个技巧并不会对测试误差产生较大的波动。
Alex Krizhevsky络,
仅特征图的数量就达几百张,而我们的网络中只有9张。从9-13中的测试误差我
们可以看到,经过5000个周期的训练后,这个网络实现了75.1%的正确识别率,如
果让网络继续训练,那么它将会收敛到文章[41]中号称的89%正确率。
Alex Krizhevsky络,62%
怜,糕,300
62%率,Alex Krizhevsky500075.1%率,
如果我们横向对比,Alex Krizhevsky设计的网络在训500个周期时得到的正确率
54.21%,这个效低于我们的网效果。当然,这其中并不能除一些因素的
象,倍,外,
我们没有引入避免学习的惩罚,这惩罚在一定程上会降低收敛度,但
会提最终的收性能。尽管此,我们乐观地计,如果将我们网络规模
大,并且延长训练周期,那么应该能实现80%多的识别正确率。
CIFAR-10这个任务中,我们可以看到卷积网络的威力所在,这个任务使
- 102 -
哈尔滨工业大学本科毕业设计(论文)
统的神经约只40%右的率,而使模板方法
基本是不行的。卷积网络在图像识中特征自学习性能使得它远远超机器
学习中别的算法,目前主流的图像识别技术基本由卷积网络实现。
9.6 本章小结
本章讨论了我们在MNIST据集与CIFAR-10数据集上获得的实验现象与结果
讨论。对于MNIST种数特征已经被很地预处理,没有过多噪声,也没
多的转、伸缩、位移等化的图像,那么用采用全接神经网或采用机
学习中很多别的方法也能实现很好的识别效果。但对于CIFAR-10种源自于真
生活的图片,特征并没有过预处理,并且个类别的个体带有很大的差
性,那么使全连网络并不一个较好效果。有些时候,卷积络也被看
一种波,正如我们试验中到的特征图,它将原始图像中特征自动过滤
来供下一层网络,并且这特征提取程对位移等变是不敏感的。我们曾
提过,深度习也特征学习,即神网络对数进行逐层特征提取,这些
征必须是描述原始图像特征,根这些特征能够向还原出数据的原大致
貌。法,大,杂,大,
小样本的据并不适合使深度学习处理,因为小样机器无法探索出那特征
才是分类有帮的。对于小本数据,应该在型中加入的知识,而不是
望机器自动学习这些知识,对于大的数据,如果能往模型中添加人的知
1
,那么
也能很大程度地提高机器的学习性能,毕竟人工智能业内有一句话有多少人工,
就有多少智能。
1
例如卷积网络中我们就是这样干的
- 103 -
哈尔滨工业大学本科毕业设计(论文)
结 论
本文主要目的于介绍深学习在图识别中的应用,中有两条主线
穿全文。我先从控制论与器学习的系说起,随后引入了一个刻画数据
布的型即受限玻尔曼机,为了介绍限玻尔兹曼机训练方法,我们讨论
马尔夫链蒙特卡罗法。在受限玻尔曼机的基础上,我们论了如何利用
们堆得到深度置信络,并介绍了反传播算法。至此我们成了深度学习
第一条主线即深度置信网的讨论。随后我们展开了二条主线即卷积神网络
的讨论,并在其后介绍了神经网络的设计技巧与GPU高性能计算。
后, 果。
MNIST中,使98.7%率,使
98.9%率。CIFAR-10中,使
62%率,91%
率相差较远,但通过与Cae练的卷积网络做对比,我们乐观地认为我们的网络
仍有很大的收敛空间。
深度习作一种特征习,较传统式识别方有本化的改变,尤其
在图像识别领域。这套方法应当值得研究人员关注。
- 104 -
哈尔滨工业大学本科毕业设计(论文)
参考文献
[1] Bishop C M, et al. Pattern recognition and machine learning[M]. Vol. 1.[S.l.]:
springer New York, 2006.
[2] Vladimir N. Vapnik 原著, 张学工 . 统计机器学习理论的本[M]. 北京: 清华
大学出版社, 2000.
[3] Duda R O, Hart P E, Stork D G. Pattern classification[M].[S.l.]: John Wiley &
Sons,, 1999.
[4] Bengio Y. Learning deep architectures for AI[J]. Foundations and trends
R
in Ma-
chine Learning, 2009, 2(1):1–127.
[5] Hinton G E. To recognize shapes, first learn to generate images[J]. Progress in brain
research, 2007, 165:535–547.
[6] Hinton G, Osindero S, Teh Y W. A fast learning algorithm for deep belief nets[J].
Neural computation, 2006, 18(7):1527–1554.
[7] Hinton G. A practical guide to training restricted Boltzmann machines[J]. Momen-
tum, 2010, 9(1):926.
[8] Erhan D, Manzagol P A, Bengio Y, et al. The di culty of training deep archi-
tectures and the eect of unsupervised pre-training[C]//International Conference on
Artificial Intelligence and Statistics. .[S.l.]: [s.n.] , 2009:153–160.
[9] Bengio Y, Lamblin P, Popovici D, et al. Greedy layer-wise training of deep network-
s[J]. Advances in neural information processing systems, 2007, 19:153.
[10] Poultney C, Chopra S, Cun Y L, et al. Ecient learning of sparse representations
with an energy-based model[C]//Advances in neural information processing system-
s. .[S.l.]: [s.n.] , 2006:1137–1144.
[11] Hinton G E, Salakhutdinov R R. Reducing the dimensionality of data with neural
networks[J]. Science, 2006, 313(5786):504–507.
[12] LeCun Y, Bengio Y, Hinton G. Deep learning[J]. Nature, 2015, 521(7553):436–444.
[13] ·诺伊曼 原著, 甘子玉 . 计算机与人脑[M]. 北京: 北京大学出版社, 2010.
[14] Schmidhuber J. Deep Learning in Neural Networks: An Overview[J]. arXiv preprint
arXiv:1404.7828, 2014.
[15] Williams D R G H R, Hinton G. Learning representations by back-propagating
errors[J]. Nature, 1986:323–533.
- 105 -
哈尔滨工业大学本科毕业设计(论文)
[16] Ma-ckay, D.J.C. , 明波 等译. 息论、推理学习算法[M]. : 高等
教育出版社, 2006.
[17] Ackley D H, Hinton G E, Sejnowski T J. A learning algorithm for boltzmann ma-
chines[J]. Cognitive science, 1985, 9(1):147–169.
[18] LeCun Y, Boser B, Denker J S, et al. Backpropagation applied to handwritten zip
code recognition[J]. Neural computation, 1989, 1(4):541–551.
[19] LeCun Y, Bottou L, Bengio Y, et al. Gradient-based learning applied to document
recognition[J]. Proceedings of the IEEE, 1998, 86(11):2278–2324.
[20] Arel I, Rose D C, Karnowski T P. Deep machine learning-a new frontier in artificial
intelligence research [research frontier][J]. Computational Intelligence Magazine,
IEEE, 2010, 5(4):13–18.
[21] Salakhutdinov R. Learning deep generative models[D].[S.l.]: University of Toronto,
2009.
[22] 余凯, , 雨强, et al. 深度学习的昨天, 今天和明天[J]. 计算机研究与发展,
2013, 50(9):1799–1804.
[23] He K, Zhang X, Ren S, et al. Delving Deep into Rectifiers: Surpassing Human-Level
Performance on ImageNet Classification[J]. arXiv preprint arXiv:1502.01852, 2015.
[24] , . [M]. :
, 2010.
[25] Tom M.Mitchell 原著, 曾华军 等译. 机器学习[M]. 北京: 机械工业出版社, 2003.
[26] LeCun Y, Chopra S, Hadsell R, et al. A tutorial on energy-based learning[J]. Pre-
dicting structured data, 2006, 1:0.
[27] Andrieu C, De Freitas N, Doucet A, et al. An introduction to MCMC for machine
learning[J]. Machine learning, 2003, 50(1-2):5–43.
[28] Carreira-Perpinan M A, Hinton G E. On contrastive divergence learning[C]//. .[S.l.]:
[s.n.] , 2005.
[29] Tieleman T. Training restricted Boltzmann machines using approximations to the
likelihood gradient[C]//Proceedings of the 25th international conference on Machine
learning. .[S.l.]: [s.n.] , 2008:1064–1071.
[30] Barron A R. Universal approximation bounds for superpositions of a sigmoidal
function[J]. Information Theory, IEEE Transactions on, 1993, 39(3):930–945.
- 106 -
哈尔滨工业大学本科毕业设计(论文)
[31] Glorot X, Bordes A, Bengio Y. Deep sparse rectifier neural network-
s[C]//International Conference on Artificial Intelligence and Statistics. .[S.l.]: [s.n.]
, 2011:315–323.
[32] Boser B E, Guyon I M, Vapnik V N. A training algorithm for optimal margin
classifiers[C]//Proceedings of the fifth annual workshop on Computational learning
theory. .[S.l.]: [s.n.] , 1992:144–152.
[33] Cortes C, Vapnik V. Support-vector networks[J]. Machine learning, 1995,
20(3):273–297.
[34] Erhan D, Bengio Y, Courville A, et al. Why does unsupervised pre-training help
deep learning?[J]. The Journal of Machine Learning Research, 2010, 11:625–660.
[35] Hinton G E. Learning multiple layers of representation[J]. Trends in cognitive
sciences, 2007, 11(10):428–434.
[36] Abdel-Hamid O, Mohamed A r, Jiang H, et al. Applying convolutional neural
networks concepts to hybrid NN-HMM model for speech recognition[C]//Acoustics,
Speech and Signal Processing (ICASSP), 2012 IEEE International Conference on.
.[S.l.]: [s.n.] , 2012:4277–4280.
[37] Sukittanon S, Surendran A C, Platt J C, et al. Convolutional networks for speech
detection.[C]//. .[S.l.]: [s.n.] .
[38] LeCun Y, Bengio Y. Convolutional networks for images, speech, and time series[J].
The handbook of brain theory and neural networks, 1995, 3361(10).
[39] Bouvrie J. Notes on convolutional neural networks[J]. 2006.
[40] Lee H, Grosse R, Ranganath R, et al. Convolutional deep belief networks for
scalable unsupervised learning of hierarchical representations[C]//Proceedings of
the 26th Annual International Conference on Machine Learning. .[S.l.]: [s.n.] ,
2009:609–616.
[41] Krizhevsky A, Sutskever I, Hinton G E. Imagenet classification with deep con-
volutional neural networks[C]//Advances in neural information processing systems.
.[S.l.]: [s.n.] , 2012:1097–1105.
[42] Kruskal J B. Multidimensional scaling by optimizing goodness of fit to a nonmetric
hypothesis[J]. Psychometrika, 1964, 29(1):1–27.
[43] Simard P Y, Steinkraus D, Platt J C. Best p ractices for convolutional neural networks
applied to visual document analysis[C]//null. .[S.l.]: [s.n.] , 2003:958.
- 107 -
哈尔滨工业大学本科毕业设计(论文)
[44] Baldi P, Sadowski P J. Understanding Dropout[C] //Advances in Neural Information
Processing Systems. .[S.l.]: [s.n.] , 2013:2814–2822.
[45] Goodfellow I J, Warde-Farley D, Mirza M, et al. Maxout networks[J]. arXiv preprint
arXiv:1302.4389, 2013.
[46] Tenenbaum J B, De Silva V, Langford J C. A global geometric framework for non-
linear dimensionality reduction[J]. Science, 2000, 290(5500):2319–2323.
[47] Roweis S T, Saul L K. Nonlinear dimensionality reduction by locally linear embed-
ding[J]. Science, 2000, 290(5500):2323–2326.
[48] Sch
¨
olkopf B, Mika S, Smola A, et al. Kernel PCA pattern reconstruction via
approximate pre-images[M]//ICANN 98.[S.l.]: Springer, 1998:147–152.
[49] Mnih V. Cudamat: a CUDA-based matrix class for python[J]. Department of Com-
puter Science, University of Toronto, Tech. Rep. UTML TR, 2009, 4.
[50] Tieleman T. Gnumpy: an easy way to use GPU boards in Python[J]. Department of
Computer Science, University of Toronto, 2010.
[51] Kl
¨
ockner A, Pinto N, Lee Y, et al. PyCUDA and PyOpenCL: A Scripting-Based
Approach to GPU Run-Time Code Generation[J]. Parallel Computing, 2012,
38(3):157–174.
[52] Jia Y, Shelhamer E, Donahue J, et al. Cae: Convolutional Architecture for Fast
Feature Embedding[J]. arXiv preprint arXiv:1408.5093, 2014.
[53] Shane Cook , 苏统 . CUDAGPU[M]. :
机械工业出版社, 2014.
[54] Jason Sanders, Edward Kandrot , . GPUCUDA
[M]. 北京: 机械工业出版社, 2011.
[55] LeCun Y, Cortes C. MNIST handwritten digit database[J]. AT&T Labs [Online].
Available: http://yann. lecun. com/exdb/mnist, 2010.
[56] Krizhevsky A, Hinton G. Learning multiple layers of features from tiny images[J].
2009.
[57] Krizhevsky A, Hinton G. CIFAR-10 database[J]. Canadian Instistute for Advanced
Resserch [Online]. Available: http://www.cs.toronto.edu/ kriz/cifar.html, 2009.
- 108 -
哈尔滨工业大学本科毕业设计(论文)
哈尔滨工业大学本科毕业设计(论文)原创性声明
间,
(论文)《深度用》是本
作所得的成果。对本文的究工作做重要贡献的个和集体,均已在文中
明确式注明,其它未注明分不包含人已发表或撰过的研究成果,不存
购买、由他人代写、剽窃和伪造数据等作假行为。
本人愿为此声明承担法律责任。
作者签名 日期
- 109 -
哈尔滨工业大学本科毕业设计(论文)
致 谢
首先需要感谢的导师杨东先生。在这个题开始之我和杨老师对
触,论,习。
杨老对我十分任,并不过地干预我工作内容,让我兴趣展开究,只
在关键地方为我指导,并且深信我的实验能成功。感谢杨老师对我的信任与支持,
让我有足够多的时间与信心来深入研究这个课题,特此致敬。
其次需要感谢算机学院件实验室陈慧鹏先生。陈师是我大学四
的思启蒙教师,教会了我何思考以人生的意义,他趣的《计算机组
原理》课程终使走上计算的道路,如果没遇到陈老师,或大学四年
都找到自己兴趣所在。陈师为我提了舒适的实验条件与计算资源,在
个实验室中我完成了论文的大部分研究工作,再次感谢陈老师的支持与帮助。
特别感谢计算学院模式别研究中的刘家锋先生。曾旁听过刘老
的《模识别》课程,刘老课堂严谨的授方式,信手来的式推导使
折服。承蒙老师嫌弃我学疏浅,在课后仍我解惑释疑,在忙之中抽
时间帮我审阅论文,我的感激之情难以言表。
生,《机
习》课程深浅出,生动将枯燥复的数学语形象化,在年初实验遇到
见,点,
十分感谢他的无私帮助。
最后还需要感在实验室到的几位知名的老师,其一位老师为我
答了器学习与模式别两者间差异性,这个问题长困扰着我。另一位与
师,使化。
还有位给予我鼓励老师,遗憾的是并不知道他们姓名,但我仍需要对
们表示崇高的敬意。
我的字表能力不强,大家我的文也可以受到,文字足以表达
的感之情,没有以上多位师以及我边的同学给予的支持,这篇论文将
法完成。最后的最后,让我再一次将我的敬意献给以上的多位老师以及同学。
- 110 -
哈尔滨工业大学本科毕业设计(论文)
附录 A 深度置信网络源代码
MNIST码。中,
我们使用Gnumpy库为程序加速,使得原本需要执行大约需要一个月的训练只需要
1天之内完成。出于页面限制,我们对代码进行了一些格式调整,这使得代码格
式看来并规范。此外,为了面简洁,我删除一部分无代码,由于
我写下这代码的时候,只有我和上知道这些代码竟干了什么而现在剩下
上帝道了,所以我不确定否删掉了些看起来无用有用的代码。因此这
代码不一能执行成功,但是读者可照这些代码的体思路自行根据自的语
言背景重新实现一遍。
这几个文件中,Main.py是整个程序的主入口。MNIST.py是一个工具文件,主
要提供获数据集以及绘制图像功能,需要注意的是,对MNIST,我们已
数据的前几个字节中的魔数去掉了,所以如果你的数据是直接MNIST官网
取的话,在读取数据的时候需要跳过几个字节,具体的参考官方文档。RBM.py
件。softmax.pysoftmax类,RBM
类,并且对training()方法进行重写,从而实现多态性。DBNs.py是深度置信网络的
类文件,它由多个RBM与一个softmax组成,可对其执行分层的预训练与全局的权
值微调。
代码 A.1 Main.py
1 from numpy import
2 from DBNs impo rt
3 i mport numpy a s np
4
5 nodeNum = [ 7 8 4 , 62 1 , 98 2 , 6 0 0 , 41 0 , 5 6 9 , 1 0 ]
6 dbn = DBNs( nodeNum )
7 # dbn = DBNs ( nodeNum , l o a d P a r a m e t e r =Tr ue )
8 dbn . p r e T r a i n i n g ( )
9 # dbn . r e c o n s t r u c t ( )
10 dbn . r e c o g n i z e ( )
- 111 -
代码 A.2 MNIST.py
1 from s t r u c t imp ort
2 from numpy import
3 from s c i p y i mport mi s c
4 i mport Image
5
6 d e f g e t D a t a ( ) :
7 t r a i n i n g F i l e = open ( r t r a i n i n g D a t a , r b )
8 t r a i n i n g D a t a = f r o m f i l e ( t r a i n i n g F i l e , d t y p e = u i n t 8 )
9 . r e s h a p e ( 1 , 7 8 4)
10 t r a i n i n g F i l e . c l o s e ( )
11
12 t r a i n i n g L a b e l F i l e = open ( r t r a i n i n g L a b e l , r b )
13 t r a i n i n g L a b e l = f r o m f i l e ( t r a i n i n g L a b e l F i l e , d t y p e= u i n t 8 )
14 t r a i n i n g L a b e l F i l e . c l o s e ( )
15
16 t e s t I m a g e F i l e = open ( r t e s t D a t a , r b )
17 t e s t D a t a = f r o m f i l e ( t e s t I m a g e F i l e , d t y p e = u i n t 8 )
18 . r e s h a p e ( 1 , 7 8 4)
19 t e s t I m a g e F i l e . c l o s e ( )
20
21 t e s t L a b e l F i l e = open ( r t e s t L a b e l , r b )
22 t e s t L a b e l = f r o m f i l e ( t e s t L a b e l F i l e , d t y p e = u i n t 8 )
23 t e s t L a b e l F i l e . c l o s e ( )
24 r e t u r n t r a i n i n g D a t a , t r a i n i n g L a b e l , t e s t D a t a , t e s t L a b e l
25
26 d e f c r e a t e B i n D a t a ( t r a i n i n g D a t a , t r a i n i n g L a b e l ,
27 t e s t D a t a , t e s t L a b e l ) :
28 t r a i n i n g D a t a = ( 25 5 t r a i n i n g D a t a ) / 2 5 5 . 0
29 s c a l e = random . random ( t r a i n i n g D a t a . s h a p e )
30 t r a i n i n g D a t a [ g r e a t e r ( t r a i n i n g D a t a , s c a l e ) ] = 1
31 t r a i n i n g D a t a [ l e s s e q u a l ( t r a i n i n g D a t a , s c a l e ) ] = 0
32 t r a i n i n g D a t a = u i n t 8 ( t r a i n i n g D a t a )
- 112 -
33 f p = open ( r b i n T r a i n i n g D a t a 0 , wb )
34 f p . w r i t e ( t r a i n i n g D a t a )
35 f p . c l o s e ( )
36
37 t e s t D a t a = (2 5 5 t e s t D a t a ) / 2 5 5 . 0
38 s c a l e = random . random ( t e s t D a t a . s h ap e )
39 t e s t D a t a [ g r e a t e r ( t e s t D a t a , s c a l e ) ] = 1
40 t e s t D a t a [ l e s s e q u a l ( t e s t D a t a , s c a l e ) ] = 0
41 t e s t D a t a = u i n t 8 ( t e s t D a t a )
42 f p = open ( r b i n T e s t D a t a , wb )
43 f p . w r i t e ( t e s t D a t a )
44 f p . c l o s e ( )
45
46 d e f g e t B i n D a t a ( ) :
47 t r a i n i n g I m a g e F i l e = open ( r b i n T r a i n i n g D a t a 0 , r b )
48 t r a i n i n g D a t a = f r o m f i l e ( t r a i n i n g I m a g e F i l e , d t y p e= u i n t 8 )
49 . r e s h a p e ( 1 , 7 8 4)
50 t r a i n i n g I m a g e F i l e . c l o s e ( )
51
52 t r a i n i n g L a b e l F i l e = open ( r t r a i n i n g L a b e l , r b )
53 t r a i n i n g L a b e l = f r o m f i l e ( t r a i n i n g L a b e l F i l e , d t y p e= u i n t 8 )
54 t r a i n i n g L a b e l F i l e . c l o s e ( )
55
56 t e s t I m a g e F i l e = open ( r b i n T e s t D a t a , r b )
57 t e s t D a t a = f r o m f i l e ( t e s t I m a g e F i l e , d t y p e = u i n t 8 )
58 . r e s h a p e ( 1 , 7 8 4)
59 t e s t I m a g e F i l e . c l o s e ( )
60
61 t e s t L a b e l F i l e = open ( r t e s t L a b e l , r b )
62 t e s t L a b e l = f r o m f i l e ( t e s t L a b e l F i l e , d t y p e = u i n t 8 )
63 t e s t L a b e l F i l e . c l o s e ( )
64 r e t u r n d o u b l e ( t r a i n i n g D a t a ) , t r a i n i n g L a b e l ,
65 d o u b l e ( t e s t D a t a ) , t e s t L a b e l
- 113 -
哈尔滨工业大学本科毕业设计(论文)
66 d e f l o a d T r a i n i n g D a t a ( l a y e r , d i me n si o n ) :
67 f i le N a m e = b i n T r a i n i n g D a t a + s t r ( l a y e r )
68 f p = open ( f il eN ame , r b )
69 t r a i n i n g D a t a = f r o m f i l e ( fp , d t y p e = u i n t 8 )
70 . r e s h a p e ( 1 , d i me n s i o n )
71 f p . c l o s e ( )
72 r e t u r n t r a i n i n g D a t a
73
74 d e f c r e a t e I m a g e ( d a t a , imageName = temp , mode = j p g ,
75 t r a n s = True , showNow = F a l s e ) :
76 i f t r a n s == Tru e :
77 ima ge = 255 d a t a
78 e l s e :
79 ima ge = d a t a
80 image . s ha p e = 2 8 , 28
81 imageName = imageName + . + mode
82 misc . im s ave ( imageName , image )
83 i f show Now == Tr u e :
84 ima ge = Image . open ( imageName )
85 ima ge . show ( )
86 d e f c r e a t e B i n I m a g e ( da t a , imageName = temp , mode = j p g ,
87 t r a n s = F a l s e , sh owNow = F a l s e ) :
88 i f t r a n s == Tru e :
89 ima ge = f l o a t 6 4 ( 1 d a t a )
90 e l s e :
91 ima ge = f l o a t 6 4 ( d a t a )
92 image . s ha p e = 2 8 , 28
93 imageName = imageName + . + mode
94 misc . im s ave ( imageName , image )
95 i f show Now == Tr u e :
96 ima ge = Image . open ( imageName )
97 ima ge . show ( )
- 114 -
代码 A.3 RBM.py
1 i mport numpy a s np
2 i mport gnumpy a s GPU
3 from s c i p y i mport s t a t s
4 i mport s c i p y . weave a s weave
5 from MNISTData impor t
6
7 c l a s s RBM:
8 d e f i n i t ( s e l f , l a y e r , v is Hi d , k =1 ,
9 l e a r n i n g R a t e = 0 . 0 0 1 , maxEpoch = 1 0 0 ,
10 l o a d P a r a m e t e r = F a l s e ) :
11 s e l f . l a y e r = l a y e r
12 s e l f . numVis = v i s H i d [ 0 ]
13 s e l f . numHid = v i s H i d [ 1 ]
14 s e l f . k = k
15 s e l f . l e a r n i n g R a t e = l e a r n i n g R a t e
16 s e l f . maxEpoch = maxEpoch
17 i f l o a d P a r a m e t e r == F a l s e :
18 p r i n t i n i t , s t r ( l a y e r )+ t h RBM s p a r a m e t e r s
19 Ga u s s i a n = s t a t s . norm ( 0 , 0 . 0 1 )
20 s e l f .W = np . a r r a y ( G a u s s i a n . r v s (
21 ( s e l f . numHid , s e l f . numVis ) ) , np . f l o a t 3 2 )
22 t r a i n i n g D a t a = l o a d T r a i n i n g D a t a ( s e l f . l a y e r ,
23 s e l f . numVis )
24 p = np . mean ( t r a i n i n g D a t a , a x i s = 0 )
25 p = np . t r u e d i v i d e ( p , s u b t r a c t ( 1 . 0 0 0 1 , p ) )
26 s e l f . v i s B a i s = np . l o g ( p ) . r e s h a p e ( s e l f . numVis , 1 )
27 s e l f . h i d B a i s = np . z e r o s ( ( s e l f . numHid , 1 ) , d o u bl e )
28 s e l f . f e a t u r e E x t r a c t ( )
29 e l s e :
30 p r i n t l o a d , s t r ( l a y e r )+ t h RBM s p a r e m e t e r s
31 s e l f .W, s e l f . v i s B a i s , s e l f . h i d B a i s =
32 s e l f . l o a d P a r a m e t e r ( )
- 115 -
33 d e f t r a i n i n g ( s e l f ) :
34 from gnumpy import l o g i s t i c
35 de f s a mp le H id Giv en V is ( w eig h t , v t , h i d B a i s ) :
36 h = GPU . l o g i s t i c (GPU . d o t ( w ei g ht , v t ) + h i d B a i s )
37 hSample = h . r a n d ( ) < h
38 r e t u r n hSample
39 de f s a mp le V is Giv en H id ( w eig h t , h t , v i s B a i s ) :
40 v = GPU . l o g i s t i c (GPU . d o t ( w e i g h t . T , h t )+ v i s B a i s )
41 vSample = v . r a n d ( ) < v
42 r e t u r n vSample
43
44 S = l o a d T r a i n i n g D a t a ( s e l f . l a y e r , s e l f . numVis )
45 S = np . f l o a t 3 2 ( S )
46 maxBatch = 100
47 S . s h ap e = maxBatch , 1 , s e l f . numVis
48 momentum = 0 . 9
49 e t a = 0 . 0 0 1
50
51 f o r e p och i n r a n g e ( s e l f . maxEpoch ) :
52 w e i g h t = GPU . g a r r a y ( s e l f .W)
53 v i s B a i s = GPU . g a r r a y ( s e l f . v i s B a i s )
54 h i d B a i s = GPU . g a r r a y ( s e l f . h i d B a i s )
55 d e l t a W e i g h t = GPU . z e r o s ( w e i g h t . s h a p e )
56 d e l t a V i s B a i s = GPU . z e r o s ( s e l f . v i s B a i s . s h a p e )
57 d e l t a H i d B a i s = GPU . z e r o s ( s e l f . h i d B a i s . s h ap e )
58 f o r b a t c h i n r a n g e ( maxBatch ) :
59 v 0 = GPU . g a r r a y ( S [ b a t c h ] . T )
60 v t = GPU . g a r r a y ( S [ b a t c h ] . T )
61 f o r i i n r a n g e ( s e l f . k ) :
62 h t =s am p le Hi d Gi ve n Vi s ( we i ght , v t , h i d B a i s )
63 v t =s am p le Vi s Gi ve n Hi d ( we i ght , h t , v i s B a i s )
64 p r o b 0 = GPU . l o g i s t i c (GPU . d o t ( w e ig h t , v 0 )
65 + h i d B a i s )
- 116 -
66 p r o b t = GPU . l o g i s t i c (GPU . d o t ( w e igh t , v t )
67 + h i d B a i s )
68 d e l t a W e i g h t = momentum d e l t a W e i g h t + e t a
69 (GPU . d o t ( p ro b 0 , v 0 . T )
70 GPU . d o t ( p r o b t , v t . T ) )
71 d e l t a V i s B a i s = momentum d e l t a V i s B a i s + e t a
72 ( v 0 . sum ( 1 ) v t . sum ( 1 ) )
73 . r e s h a p e ( 1 , 1 )
74 d e l t a H i d B a i s = momentum d e l t a H i d B a i s + e t a
75 ( p r o b 0 . sum (1) p r o b t . sum ( 1 ) )
76 . r e s h a p e ( 1 , 1 )
77 w e i g h t += d e l t a W e i g h t / maxBatch
78 h i d B a i s += d e l t a H i d B a i s / maxBatch
79 v i s B a i s += d e l t a V i s B a i s / maxBatch
80 s e l f .W = w e i g h t . a s n u m p y a r r a y ( )
81 s e l f . v i s B a i s = v i s B a i s . a s n u m p y a r r a y ( )
82 s e l f . h i d B a i s = h i d B a i s . a s n u m p y a r r a y ( )
83 p r i n t epoch , epoch c o m p l e t e !
84 s e l f . s a v e P a r a m e t e r ( )
85 p r i n t t r a i n i n g , s t r ( s e l f . l a y e r )+ t h , ”RBM c o m p l e t e
86 s e l f . f e a t u r e E x t r a c t ( )
87
88 d e f s a v e P a r a m e t e r ( s e l f ) :
89 f p = open ( r w e i g h t + s t r ( s e l f . l a y e r ) , wb )
90 f p . w r i t e ( s e l f .W)
91 f p . c l o s e ( )
92 f p = open ( r v i s B a i s + s t r ( s e l f . l a y e r ) , wb )
93 f p . w r i t e ( s e l f . v i s B a i s )
94 f p . c l o s e ( )
95 f p = open ( r h i d B a i s + s t r ( s e l f . l a y e r ) , wb )
96 f p . w r i t e ( s e l f . h i d B a i s )
97 f p . c l o s e ( )
98 p r i n t l a y e r , s e l f . l a y e r , p a r a m e t e r s had b e e n s a v e
- 117 -
99 d e f l o a d P a r a m e t e r ( s e l f ) :
100 f p = open ( r w e ig h t + s t r ( s e l f . l a y e r ) , r b )
101 w e i g h t = f r o m f i l e ( fp , d t y p e = d o u b l e )
102 . r e s h a p e ( s e l f . numHid , s e l f . numVis )
103 f p . c l o s e ( )
104 f p = open ( r v i s B a i s + s t r ( s e l f . l a y e r ) , r b )
105 v i s B a i s = f r o m f i l e ( fp , d t y p e = d o u b l e )
106 . r e s h a p e ( s e l f . numVis , 1 )
107 f p . c l o s e ( )
108 f p = open ( r h i d B a i s + s t r ( s e l f . l a y e r ) , r b )
109 h i d B a i s = f r o m f i l e ( fp , d t y p e = d o u b l e )
110 . r e s h a p e ( s e l f . numHid , 1 )
111 f p . c l o s e ( )
112 re tu r n we i ght , v i s B a i s , h i d B a i s
113
114 d e f f e a t u r e E x t r a c t ( s e l f , l o w F e a t u r e = None ) :
115 i f l o w F e a t u r e == None :
116 l o w F e a t u r e = l o a d T r a i n i n g D a t a ( s e l f . l a y e r ,
117 s e l f . numVis )
118 numCase = l o w F e a t u r e . s h ap e [ 0 ]
119 h i g h F e a t u r e = z e r o s ( ( numCase , s e l f . numHid ) ,
120 d t y p e = u i n t 8 )
121 f o r c a s e i n r a n g e ( numCase ) :
122 p r ob = 1 . 0 / ( 1 + np . exp (
123 np . d o t ( l o w F e a t u r e [ c a s e ] , s e l f .W. T )
124 s e l f . h i d B a i s . T ) )
125 s c a l e = np . random . random ( p ro b . s h a p e )
126 temp = z e r o s ( p ro b . sh a pe , d t y p e = np . u i n t 8 )
127 temp [ l e s s ( s c a l e , p r ob ) ] = 1
128 h i g h F e a t u r e [ c a s e ] = temp
129
130 f il e N a m e = b i n T r a i n i n g D a t a + s t r ( s e l f . l a y e r +1)
131 f p = open ( f i leN a me , wb )
- 118 -
哈尔滨工业大学本科毕业设计(论文)
132 f p . w r i t e ( h i g h F e a t u r e )
133 f p . c l o s e ( )
134 p r i n t h i g h f e a t u r e had be e n e x t r a c t e d !
135 e l s e :
136 pr ob = 1 . 0 / ( 1 + np . exp ( np . d o t ( l o w F e a t u r e , s e l f .W. T )
137 s e l f . h i d B a i s . T ) )
138 r e t u r n p ro b
139
140 d e f r e c o n s t r u c t ( s e l f , h i g h F e a t u r e ) :
141 h i g h F e a t u r e . s h a pe = 1 , 1
142 pr o b = 1 . 0 / ( 1 + np . exp (np . d o t ( h i g h F e a t u r e , s e l f .W)
143 s e l f . v i s B a i s . T ) )
144 re tu r n p r ob
- 119 -
代码 A.4 softmax.py
1 from RBM impo rt
2 from s c i p y . o dr . o d r p ac k import O ut pu t
3
4 c l a s s s o f t m a x (RBM) :
5 d e f i n i t ( s e l f , l a y e r , v is Hi d ,
6 l e a r n i n g R a t e = 0 . 0 0 1 , maxEpoch = 5 ,
7 l o a d P a r a m e t e r = F a l s e ) :
8 s e l f . l a y e r = l a y e r
9 s e l f . numVis = v i s H i d [ 0 ]
10 s e l f . numHid = v i s H i d [ 1 ]
11 s e l f . l e a r n i n g R a t e = l e a r n i n g R a t e
12 s e l f . maxEpoch = maxEpoch
13 i f l o a d P a r a m e t e r == F a l s e :
14 p r i n t i n i t , s t r ( l a y e r )+ t h RBM s p a r a m e t e r s
15 G a u s s i a n = s t a t s . norm ( 0 , 0 . 0 1 )
16 s e l f .W = np . a r r a y ( G a u s s i a n . r v s (
17 ( s e l f . numHid , s e l f . numVis ) ) , d o u b l e )
18 t r a i n i n g D a t a = l o a d T r a i n i n g D a t a ( s e l f . l a y e r ,
19 s e l f . numVis )
20 p = np . mean ( t r a i n i n g D a t a , a x i s = 0 )
21 p = np . t r u e d i v i d e ( p , s u b t r a c t ( 1 . 0 0 0 1 , p ) )
22 s e l f . v i s B a i s = np . l o g ( p ) . r e s h a p e ( s e l f . numVis , 1 )
23 s e l f . h i d B a i s = np . z e r o s ( ( s e l f . numHid , 1 ) , d o u bl e )
24 s e l f . s a v e P a r a m e t e r ( )
25 e l s e :
26 p r i n t l o a d , s t r ( l a y e r )+ t h RBM s p a r e m e t e r s
27 s e l f .W, s e l f . v i s B a i s , s e l f . h i d B a i s =
28 s e l f . l o a d P a r a m e t e r ( )
29 d e f t r a i n i n g ( s e l f ) :
30 G a u s s i an = s t a t s . norm ( 0 , 0 . 0 0 1 )
31 t r a i n i n g D a t a = l o a d T r a i n i n g D a t a ( s e l f . l a y e r ,
32 s e l f . numVis )
- 120 -
哈尔滨工业大学本科毕业设计(论文)
33 t r a i n i n g L a b e l = g e t B i n D a t a ( ) [ 1 ]
34 numCase = t r a i n i n g D a t a . s ha p e [ 0 ]
35 w e i g h t = np . a r r a y ( G a u s s i a n . r v s ( s i z e =( s e l f . numHid ,
36 s e l f . numVis + 1 ) ) ,
37 d t y p e = d o u b l e )
38 f o r e p och i n r a n g e ( s e l f . maxEpoch ) :
39 f o r i i n r a n g e ( numCase ) :
40 sa m ple = t r a i n i n g D a t a [ i ] . r e s h a p e ( 1 , 1 )
41 t a r g e t = t r a i n i n g L a b e l [ i ]
42 sa m ple = v s t a c k ( ( 1 , sa m pl e ) )
43 t a r g e t O u t = np . exp ( d o t ( w e igh t , s am pl e ) )
44 . r e s h a p e ( 1)
45 Z = sum ( t a r g e t O u t )
46 t a r g e t O u t = ( t a r g e t O u t / Z ) . r e s h a p e ( 1 , 1 )
47 d e l t a =d o t ( t a r g e t O u t , sa mp le . r e s h a p e ( 1 , 1 ) )
48 d e l t a [ t a r g e t ] += s a mpl e . r e s h a p e ( 1 )
49 d e l t a += 0 . 0 0 5 w e i g h t
50 w e i g h t += 0 . 0 0 1 d e l t a
51 s e l f .W = copy ( w e i g h t [ : , 1 : ]
52 . r e s h a p e ( s e l f .W. s h a p e ) )
53 s e l f . h i d B a i s = copy ( w e i g h t [ : , 0 ] . r e s h a p e (
54 s e l f . h i d B a i s . s h a p e ) )
55 p r i n t epoch , c o m p l e t e
56 p r i n t t r a i n i n g , s t r ( s e l f . l a y e r )+ t h , ”RBM c o m p l e t e
57 s e l f . s a v e P a r a m e t e r ( )
58
59 d e f f e a t u r e E x t r a c t ( s e l f , l o w F e a t u r e ) :
60 pr o b=np . exp ( d o t ( l o w F e a t u r e , s e l f .W. T)+ s e l f . h i d B a i s . T )
61 Z = sum ( p r ob )
62 pr o b = ( p r ob / Z )
63 re tu r n p r ob
- 121 -
代码 A.5 DBNs.py
1 from numpy import
2 from RBM impo rt
3 from s of t ma x import
4 from MNISTData impor t
5
6 c l a s s DBNs :
7 d e f i n i t ( s e l f , no deNum , l o a d P a r a m e t e r = F a l s e ) :
8 s e l f . r bm P ai r = z i p ( nodeNum [ : 1 ] , nodeNum [ 1 : ] )
9 rb msNum = l e n ( nodeNum ) 1
10 s e l f . rbms = [ None f o r i i n r a n g e ( rbmsNum ) ]
11 i f l o a d P a r a m e t e r == T ru e :
12 f o r i i n r a n g e ( rbmsNum ) :
13 i f i != rbmsNum 1 :
14 s e l f . rbms [ i ] = RBM( i , s e l f . r bm P ai r [ i ] ,
15 l o a d P a r a m e t e r = True )
16 e l s e :
17 s e l f . rbms [ i ]= s o f t m a x ( i , s e l f . r b m P a i r [ i ] ,
18 l o a d P a r a m e t e r = True )
19 e l s e :
20 f o r i i n r a n g e ( rbmsNum ) :
21 i f i != rbmsNum 1 :
22 s e l f . rbms [ i ] = RBM( i , s e l f . r b m P a i r [ i ] )
23 e l s e :
24 s e l f . rbms [ i ]= s o f t m a x ( i , s e l f . r b m P a i r [ i ] )
25
26 d e f p r e T r a i n i n g ( s e l f ) :
27 f o r rbm i n s e l f . rbms :
28 rbm . t r a i n i n g ( )
29 p r i n t DBNs had pr e t r a i n e d c o m p l e t e !
30
31
32
- 122 -
33 d e f f i n e T u n i n g ( s e l f , maxEpoch = 1 0 ) :
34 import gnumpy a s GPU
35 de f makeBatch ( maxBatch = 1 0 0 ) :
36 t r a i n i n g D a t a = (255 g e t D a t a ( ) [ 0 ] ) / 2 5 5 . 0
37 t r a i n i n g D a t a = g e t B i n D a t a ( ) [ 0 ]
38 t r a i n i n g D a t a = h s t a c k (
39 ( o ne s ( ( t r a i n i n g D a t a . s h a pe [ 0 ] , 1 ) ) ,
40 t r a i n i n g D a t a ) )
41 l a b e l = g e t B i n D a t a ( ) [ 1 ]
42 t r a i n i n g L a b e l = np . z e r o s ( ( numCase , 1 0 ) )
43 t r a i n i n g L a b e l [ [ i f o r i i n r a n g e ( numCase ) ] ,
44 l a b e l ] = 1
45 r e t u r n t r a i n i n g D a t a . r e s h a p e ( maxBatch , 1 , 7 8 5 ) ,
46 t r a i n i n g L a b e l . r e s h a p e ( maxBatch , 1 ,10 ) ,
47
48 de f g e t A b s t r a c t ( we i gh t , i n p u t ) :
49 pr ob = [ i n p u t ]
50 f o r W i n we i g h t [ : 1 ] :
51 temp = GPU . d o t ( p ro b [ 1 ] , W. T ) . l o g i s t i c ( )
52 temp = h s t a c k ( ( o n es ( ( temp . s ha p e [ 0 ] , 1 ) ) ,
53 temp . a s n u m p y a r r a y ( ) ) )
54 p r ob . append (GPU . g a r r a y ( temp ) )
55 o u t p u t =GPU . exp (GPU . d o t ( p ro b [ 1 ] , w e i gh t [ 1 ] . T ) )
56 Z = GPU . sum ( o u t p u t , a x i s = 1 ) . r e s h a p e ( 1 , 1 )
57 o u t p u t = o u t p u t / Z
58 pr ob . r e v e r s e ( )
59 r e t u r n prob , o u t p u t
60 de f weight2GPU ( ) :
61 w e i g h t = [ ]
62 f o r rbm i n s e l f . rbms :
63 temp=GPU . g a r r a y ( h s t a c k ( ( rbm . h i d B a i s , rbm .W) ) )
64 w e i g h t . ap p e n d ( temp )
65 r e t u r n we i g h t
- 123 -
66 p r i n t s t a r t t o f i n e t u n i n g
67 maxEpoch = 200
68 maxBatch = 300
69 t r a i n i n g D a t a , t r a i n i n g L a b e l = makeBatch ( maxBatch )
70 numCase = t r a i n i n g D a t a . s ha p e [ 1 ]
71 w e i g h t = weight2GPU ( )
72 e p s i l o n = 0. 9 9 9
73 l e a r n i n g R a t e = 0 . 1
74 t r a i n i n g D a t a = GPU . g a r r a y ( t r a i n i n g D a t a )
75 t r a i n i n g L a b e l = GPU . g a r r a y ( t r a i n i n g L a b e l )
76 f o r e p och i n r a n g e ( maxEpoch ) :
77 s e l f . r e c o g n i z e ( )
78 f o r i i n r a n g e ( maxBatch ) :
79 i n p u t = t r a i n i n g D a t a [ i ]
80 t a r g e t = t r a i n i n g L a b e l [ i ]
81 prob , o u t p u t = g e t A b s t r a c t ( w e igh t , i n p u t )
82 s e n s = t a r g e t o u t p u t
83 w e i g h t . r e v e r s e ( )
84 f o r W, X, i n d e x i n z i p ( w e igh t , prob ,
85 r a n g e ( l e n ( w e ig h t ) ) ) :
86 d e l t a = GPU . d o t ( s e n s . T , X)
87 s e n s = GPU . d o t ( se ns , W) X ( 1 X)
88 s e n s = s e n s [ : , 1 : ]
89 w e i g h t [ i n d e x ] += l e a r n i n g R a t e d e l t a
90 / ( numCase )
91 w e i g h t . r e v e r s e ( )
92 p r i n t epoch , c o m p l e t e !
93 f o r rbm , W i n z i p ( s e l f . rbms , w e i g h t ) :
94 rbm .W = ( e p s i l o n W[ : , 1 : ] ) . a s n u m p y a r r a y ( )
95 rbm . h i d B a i s = W[ : , 0 ] . a s n u m p y a r r a y ( )
96 f o r rbm i n ( s e l f . rbms ) :
97 rbm . s a v e P a r a m e t e r ( )
98
- 124 -
99 d e f r e c o n s t r u c t ( s e l f , numCase =100 , t r a i n i n g D a t a =None ) :
100 i f t r a i n i n g D a t a == None :
101 t r a i n i n g D a t a = g e t B i n D a t a ( ) [ 0 ]
102 pureRBM = s e l f . rbms [ : 1 ]
103 f o r i i n r a n g e ( numCase ) :
104 sa m ple = t r a i n i n g D a t a [ i ]
105 a b s t r a c t = s a mpl e
106 f o r rbm i n pureRBM :
107 a b s t r a c t = rbm . f e a t u r e E x t r a c t ( a b s t r a c t )
108 p ureRB M . r e v e r s e ( )
109 f o r rbm i n pureRBM :
110 a b s t r a c t = rbm . r e c o n s t r u c t ( a b s t r a c t )
111 p ureRB M . r e v e r s e ( )
112 imageName = r e c o n s t r u c t + s t r ( i )
113 c r e a t e I m a g e ( 2 55 a b s t r a c t , imageName ,
114 showNow = F a l s e , t r a n s = F a l s e )
115 e l s e :
116 pureRBM = s e l f . rbms [ : 1 ]
117 a b s t r a c t = t r a i n i n g D a t a
118 f o r rbm i n pureRBM :
119 a b s t r a c t = rbm . f e a t u r e E x t r a c t ( a b s t r a c t )
120 pureRBM . r e v e r s e ( )
121 f o r rbm i n pureRBM :
122 a b s t r a c t = rbm . r e c o n s t r u c t ( a b s t r a c t )
123 s c a l e = np . random . random ( a b s t r a c t . s h a pe )
124 temp = z e r o s ( a b s t r a c t . s h a p e )
125 temp [ l e s s ( s c a l e , a b s t r a c t ) ] = 1
126 c r e a t e I m a g e ( 2 55 a b s t r a c t ,
127 showNow = F a l s e , t r a n s = F a l s e )
128 r e t u r n temp
129
130
131
- 125 -
哈尔滨工业大学本科毕业设计(论文)
132 d e f r e c o g n i z e ( s e l f , t e s t D a t a = None , t e s t L a b e l = None ) :
133 i f t e s t D a t a == None or t e s t L a b e l == None :
134 t e s t D a t a = (255 g e t D a t a ( ) [ 2 ] ) / 2 5 5 . 0
135 # t e s t D a t a = g e t B i n D a t a ( ) [ 2 ]
136 t e s t L a b e l = g e t B i n D a t a ( ) [ 3 ]
137 numCase = t e s t D a t a . s h a pe [ 0 ]
138 maxBatch = 100
139 t e s t D a t a . s h a pe = maxBatch , 1 , 784
140 t e s t L a b e l . s h a pe = maxBatch , 1
141 e l s e :
142 numCase = t e s t D a t a . s h a pe [ 0 ] t e s t D a t a . s ha p e [ 1 ]
143 maxBatch = t e s t D a t a . s h a pe [ 0 ]
144
145 c o u n t = 0
146 f o r i i n r a n g e ( maxBatch ) :
147 i n p u t = t e s t D a t a [ i ]
148 o u t p u t = i n p u t
149 f o r rbm i n s e l f . rbms :
150 o u t p u t = rbm . f e a t u r e E x t r a c t ( o u t p u t )
151 g u e s t = argmax ( o u t p u t , a x i s = 1 )
152 b in g o = g u e s t == t e s t L a b e l [ i ]
153 c o u n t += sum ( b i n go )
154 p r i n t c o r r e c t r a t e = , s t r ( 1 0 0 . 0 c o u n t / numCase )+ %
- 126 -
哈尔滨工业大学本科毕业设计(论文)
附录 B 卷积神经网络源代码
本附CIFAR使用的网络码,由于MNIST
这里类似,只是构造器有微的不同,因此我们不打算提MNIST中卷积网络的
代码,读者可经过很少的改动便可将以下的代码改写成训练MNIST数据集的代码。
在这几个文件中,Main.py是整个程序的入口。CIFAR.py是工具文件,它提供获取
数据集以及绘制图像的功能。FormatLayer.py是最顶层特征图展开成列向量所经过
层。CNNs.py件,它
播和反向传播。SubsamplingLayer.py是采样层类文件。ConvLayer.py是卷积层类
件。FullConnectLayer.py是全连接层的类文件。可以看到,整个网络的代码已经被
我们成紧耦合的了,我们有时间将些代码写成松合形式,有兴趣的读
可进尝试。另外,于版面的题,我们对码的式进行了整,因此直
拷贝些代码是不会行的,你需要再新调整他们的式。我们对数据集进
了镜处理,因此们总共有10次的据集,进行像镜像仅只是将矩
翻转,很容易实现,所以在这里我们就不贴代码了。
代码 B.1 FormatLayer.py
1 from CNNs impo rt
2 cnn = CNNs ( l o a d = F a l s e )
3 cnn . t r a i n ( )
4 c o r r e c t R a t e = cnn . t e s t i n g ( )
5 p r i n t c o r r e c t R a t e
- 127 -
哈尔滨工业大学本科毕业设计(论文)
代码 B.2 CIFAR.py
1 from numpy import
2 from s c i p y i mport mi s c
3 i mport Image
4
5 d e f u n p i c k l e ( f i l e ) :
6 imp ort c P i c k l e
7 f o = open ( f i l e , r b )
8 d i c t = c P i c k l e . l o a d ( f o )
9 f o . c l o s e ( )
10 r e t u r n d i c t [ d a t a ] , a r r a y ( d i c t [ l a b e l s ] )
11
12 d e f g e t D a t a ( i ) :
13 f i le N a m e = d a t a b a t c h + s t r ( i )
14 t r a i n i n g D a t a , t r a i n i n g L a b e l = u n p i c k l e ( f i l e Na m e )
15 r e t u r n t r a i n i n g D a t a / 2 5 5 . 0 , t r a i n i n g L a b e l
16
17 d e f g e t T e s t D a t a ( ) :
18 f i le N a m e = t e s t b a t c h
19 t e s t D a t a , t e s t L a b e l = u n p i c k l e ( f i le Na m e )
20 r e t u r n t e s t D a t a / 2 5 5 . 0 , t e s t L a b e l
21
22 d e f c r e a t e I m a g e ( d a t a , imageName = temp , mode = j p g ) :
23 r e d = d a t a [ : 1 0 2 4 ]
24 g r e e n = d a t a [ 1 0 2 4 : 2 0 4 8 ]
25 b l u e = d a t a [ 2 0 4 8 : ]
26 image = a r r a y ( z i p ( red , gr ee n , b l u e ) ) . r e s h a p e ( 3 2 , 3 2 , 3 )
27 imageName = imageName + . + mode
28 misc . im s ave ( imageName , image )
- 128 -
代码 B.3 CNNs.py
1 from ConvLayer import
2 from S u b sa m p l in g L a ye r impo rt
3 from F u l l C o n n e c t L a y e r imp ort
4 i mport numpy a s np
5 from CI FAR i mport
6 from Fo rm a t L ay er import
7
8 c l a s s CNNs ( ) :
9
10 d e f i n i t ( s e l f , l o a d = F a l s e ) :
11 s e l f .CNN = [ ConvLayer ( 1 , 3 , 9 , l o a d P a r a m e t e r = l o a d ) ,
12 S u b s a mp l i n gL a y e r ( 2 ) ,
13 Fo r m a tL ay e r ( 6 , 9 , 1 4 , 1 4 ) ,
14 F u l l C o n n e c t L a y e r ( 7 , 17 6 4 , 1 0 ,
15 l o a d P a r a m e t e r = l o a d ) ]
16
17 d e f t r a i n i n g ( s e l f ) :
18 f o r i i n r a n g e ( 4 0 0 ) :
19 s e l f . t r a i n A e p o c h ( )
20 c o r r e c t R a t e = s e l f . t e s t ( ) / 1 0 0 . 0
21 p r i n t e p o c h , i , c o m p l e t e ,
22 c o r r e c t r a t e = , c o r r e c t R a t e
23 f o r l a y e r i n s e l f .CNN:
24 l a y e r . s a v e P a r a m e t e r ( )
25
26
27 d e f t r a i n A e p o c h ( s e l f ) :
28 e r r o r = 0
29 f o r b a t c h i n r a n g e ( 1 0 ) :
30 numCase = 10000
31 t r a i n i n g D a t a = g e t D a t a ( b a t c h + 1 ) [ 0 ] [ : numCase ]
32 l a b e l = g e t D a t a ( b a t c h + 1 ) [ 1 ] [ : numCase ]
- 129 -
33 t r a i n i n g L a b e l = np . z e r o s ( ( numCase , 1 0 ) )
34 t r a i n i n g L a b e l [ [ i f o r i i n r a n g e ( numCase ) ] ,
35 l a b e l ] = 1
36
37 f o r i i n r a n g e ( numCase ) :
38 r e d = t r a i n i n g D a t a [ i ] [ : 1 0 2 4 ]
39 . r e s h a p e ( 3 2 , 32 )
40 g r e e n = t r a i n i n g D a t a [ i ] [ 1 0 2 4 : 2 0 4 8 ]
41 . r e s h a p e ( 3 2 , 32 )
42 b l u e = t r a i n i n g D a t a [ i ] [ 2 0 4 8 : ]
43 . r e s h a p e ( 3 2 , 32 )
44 f e a t u r e M a p = [ r e d , g r ee n , b l u e ]
45 temp = [ f e a t u r e M a p ]
46 # f p r o p
47 f o r l a y e r i n s e l f .CNN:
48 f e a t u r e M a p = l a y e r . f p r o p ( f e a t u r e M a p )
49 temp . i n s e r t ( 0 , f e a t u r e M a p )
50 # c l a c e r r o r
51 o u t I n = z i p ( temp [ : 1 ] , temp [ 1 : ] )
52 g u e s t = temp [ 0 ]
53 l o s e F u n c D i f f A c t = g u e s t
54 t r a i n i n g L a b e l [ i ] . r e s h a p e ( 1 , 1 )
55 e r r o r += np . d o t ( l o s e F u n c D i f f A c t . T ,
56 l o s e F u n c D i f f A c t )
57 s e l f .CNN . r e v e r s e ( )
58 # b p ro b
59 f o r l a y e r , o u t I n i n z i p ( s e l f .CNN [ : ] ,
60 o u t I n [ : ] ) :
61 l o s e F u n c D i f f A c t = l a y e r . b p ro p (
62 l o s e F u n c D i f f A c t ,
63 o u t I n [ 1 ] , o u t I n [ 0 ] )
64 s e l f .CNN . r e v e r s e ( )
65 p r i n t a b a t c h co mp le t e , e r r o r = , e r r o r
- 130 -
哈尔滨工业大学本科毕业设计(论文)
66 d e f t e s t i n g ( s e l f ) :
67 t e s t D a t a = g e t T e s t D a t a ( ) [ 0 ]
68 t e s t L a b e l = g e t T e s t D a t a ( ) [ 1 ]
69 numCase = 10000
70 h i t = 0
71 f o r i i n r a n g e ( numCase ) :
72 r e d = t e s t D a t a [ i ] [ : 1 0 2 4 ] . r e s h a p e ( 3 2 , 32 )
73 g r e e n = t e s t D a t a [ i ] [ 1 0 2 4 : 2 0 4 8 ] . r e s h a p e ( 3 2 , 3 2)
74 b l u e = t e s t D a t a [ i ] [ 2 0 4 8 : ] . r e s h a p e ( 3 2 , 3 2 )
75 f e a t u r e = [ r e d , g r ee n , b l u e ]
76 f o r l a y e r , l a y e r I n d e x i n z i p ( s e l f . CNN,
77 r a n g e ( l e n ( s e l f .CNN ) ) ) :
78 f e a t u r e = l a y e r . f p r o p ( f e a t u r e )
79 g u e s t = np . argmax ( f e a t u r e )
80 l a b e l = t e s t L a b e l [ i ]
81 i f g u e s t == l a b e l :
82 h i t += 1
83 re tu r n h i t
- 131 -
代码 B.4 ConvLayer.py
1 i mport numpy a s np
2 from s c i p y . s i g n a l im port c o nv o l v e 2 d
3 from s c i p y i mport s t a t s
4
5 c l a s s ConvLayer ( ) :
6 d e f i n i t ( s e l f , l a y e r , inputMapNum , outputMapNum ,
7 k e r n e l S i z e =( 5 , 5 ) , l o a d P a r a m e t e r = F a l s e ) :
8 s e l f . l a y e r = l a y e r
9 s e l f . inputMapNum = inputMapNum
10 s e l f . outputMapNum = outputMapNum
11 s e l f . k e r n e l S i z e = k e r n e l S i z e
12 G a u s s i a n = s t a t s . norm ( 0 , 0 . 0 0 0 1 )
13 s e l f . k e r n e l = [ [ None f o r j i n r a n g e ( s e l f . outputMapNum ) ]
14 f o r i i n r a n g e ( s e l f . inputMapNum ) ]
15 i f l o a d P a r a m e t e r == F a l s e :
16 s e l f . k e r n e l = [ [ np . a r r a y ( G a u s s i a n . r v s ( k e r n e l S i z e ) )
17 f o r j i n r a n g e ( s e l f . outputMapNum ) ]
18 f o r i i n r a n g e ( s e l f . inputMapNum ) ]
19 s e l f . b i a s = np . a r r a y ( [ np . random . random ( )
20 f o r i i n r a n g e ( s e l f . outputMapNum ) ] )
21 e l s e :
22 f o r i i n r a n g e ( s e l f . inputMapNum ) :
23 f o r j i n r a n g e ( s e l f . outputMapNum ) :
24 f p = open ( r k e r n e l + s t r ( s e l f . l a y e r )
25 + ( + s t r ( i )+ , + s t r ( j )+ ) , r b )
26 s e l f . k e r n e l [ i ] [ j ] = np . f r o m f i l e ( fp ,
27 dt y p e=np . d o u b l e )
28 . r e s h a p e ( s e l f . k e r n e l S i z e )
29 f p . c l o s e ( )
30 f p = open ( r b i a s + s t r ( s e l f . l a y e r ) , r b )
31 s e l f . b i a s = np . f r o m f i l e ( fp , d t y p e=np . d o u b l e )
32 f p . c l o s e ( )
- 132 -
33 p r i n t conv l a y e r , s e l f . l a y e r ,
34 p a r a m e t e r s had b e e n l o a d e d .
35 s e l f . l e a r n i n g R a t e = 0 . 0 1
36
37 d e f s a v e P a r a m e t e r ( s e l f ) :
38 f o r i i n r a n g e ( s e l f . inputMapNum ) :
39 f o r j i n r a n g e ( s e l f . outputMapNum ) :
40 f p = open ( r k e r n e l + s t r ( s e l f . l a y e r )
41 + ( + s t r ( i )+ , + s t r ( j )+ ) , wb )
42 f p . w r i t e ( s e l f . k e r n e l [ i ] [ j ] )
43 f p . c l o s e ( )
44 f p = open ( r b i a s + s t r ( s e l f . l a y e r ) , wb )
45 f p . w r i t e ( np . a r r a y ( s e l f . b i a s ) )
46 f p . c l o s e ( )
47 p r i n t conv l a y e r , s e l f . l a y e r ,
48 p a r a m e t e r s had be en s av e .
49
50 d e f conv ( s e l f , d a t a , k e r n e l ) :
51 f e a t u r e M a p = c o n vo l ve 2 d ( d a t a , k e r n e l , mode= v a l i d )
52 re tu r n f e a t u r e M a p
53
54 d e f f p r o p ( s e l f , i np u tM a ps ) :
55 h i g h F e a t u re M a p s = [ np . z e r o s l i k e (
56 s e l f . conv ( in p ut Map s [ 0 ] ,
57 s e l f . k e r n e l [ 0 ] [ 0 ] ) )
58 f o r i i n r a n g e ( s e l f . outputMapNum ) ]
59
60 f o r inputMap , k e r n e l i i n z i p ( in p u t Map s , s e l f . k e r n e l ) :
61 ou tp u tM a ps = [ s e l f . conv ( inputMap , k e r n e l j )
62 f o r k e r n e l j i n k e r n e l i ]
63 f o r i , outputM a p i n z i p ( r a n g e ( s e l f . outputMapNum ) ,
64 ou tp ut M ap s ) :
65 h i g h F e a t u r e M a p s [ i ] += o u t p u tMap
- 133 -
66
67 f o r i i n r a n g e ( s e l f . outputMapNum ) :
68 h i g h F e a t u r e M a p s [ i ] = 1 . 0 / ( 1
69 + np . exp (h i g h F e a t u r e M a p s [ i ]
70 s e l f . b i a s [ i ] ) )
71 re tu r n h i g h F e a t u r e M a p s
72
73 d e f bp ro p ( s e l f , l os sD i f f A c tM ap , inputMap , outputM a p ) :
74 de f r o t 1 8 0 ( M a t r i x ) :
75 r e t u r n np . r o t 9 0 ( M a tri x , 2 )
76
77 a c t Di f f N et M a p = [ o u t p u t ( 1 o u t p u t )
78 f o r o u t p u t i n ou t p utMa p ]
79
80 sensMap = [ l o s s D i f f A c t a c t D i f f N e t
81 f o r l o s s D i f f A c t , a c t D i f f N e t i n
82 z i p ( l o ss Di f f A c t Ma p , a c tD i f f Ne t M a p ) ]
83
84 d e l t a K e r n e l = [ [ None f o r j i n r a n g e ( s e l f . outputMapNum ) ]
85 f o r i i n r a n g e ( s e l f . inputMapNum ) ]
86
87 f o r i i n r a n g e ( s e l f . inputMapNum ) :
88 f o r j i n r a n g e ( s e l f . outputMapNum ) :
89 d e l t a K e r n e l [ i ] [ j ] = r o t 1 8 0 ( s e l f . conv (
90 inputMap [ i ] ,
91 r o t 1 8 0 ( sensMap [ j ] ) ) )
92 s e l f . k e r n e l [ i ] [ j ] = s e l f . l e a r n i n g R a t e
93 d e l t a K e r n e l [ i ] [ j ]
94
95 f o r j i n r a n g e ( s e l f . outputMapNum ) :
96 s e l f . b i a s [ j ] = s e l f . l e a r n i n g R a t e
97 np . sum ( sensMap [ j ] )
98
- 134 -
哈尔滨工业大学本科毕业设计(论文)
99 an s = [ np . z e r o s l i k e ( i n p u t M a p [ 0 ] )
100 f o r i i n r a n g e ( s e l f . inputMapNum ) ]
101 f o r i i n r a n g e ( s e l f . inputMapNum ) :
102 f o r j i n r a n g e ( s e l f . outputMapNum ) :
103 a ns [ i ] += c o n v o lv e 2 d ( sensMap [ j ] ,
104 r o t 1 8 0 ( s e l f . k e r n e l [ i ] [ j ] ) ,
105 mode= f u l l )
106 re tu r n a ns
- 135 -
哈尔滨工业大学本科毕业设计(论文)
代码 B.5 SubsamplingLayer.py
1 i mport numpy a s np
2 from s c i p y . s i g n a l im port c o nv o l v e 2 d
3 from s c i p y . l i n a l g import k ro n
4
5 c l a s s S ub s a m pl i n g La y e r ( ) :
6
7 d e f i n i t ( s e l f , l a y e r ) :
8 s e l f . l a y e r = l a y e r
9 s e l f . k e r n e l = 0 . 2 5 np . o n es ( ( 2 , 2 ) )
10
11 d e f s u b s a m p l i n g ( s e l f , d a t a ) :
12 f e a t u r e M a p = c o n vo l ve 2 d ( d a t a , s e l f . k e r n e l ,
13 mode= v a l i d )
14 re tu r n f e a t u r e M a p [ : : 2 , : : 2 ]
15
16 d e f s a v e P a r a m e t e r ( s e l f ) :
17 p r i n t s u b s a m p l i n t l a y e r h as no p a r a m e t e r t o s a v e
18
19 d e f f p r o p ( s e l f , l owF ea t ur e Ma p s ) :
20 h i g h F e a t u re M a p s = [ s e l f . s u b s a m p l i n g ( d a t a )
21 f o r d a t a in l o wF e at u re M ap s ]
22 re tu r n h i g h F e a t u r e M a p s
23
24 d e f bp ro p ( s e l f , l os sD i f f A c tM ap , inputMap , outputM a p ) :
25 I2 x 2 = 0 . 2 5 np . on es ( ( 2 , 2 ) )
26 re tu r n [ k r on ( s en s , I 2x 2 ) f o r s e n s in l o s s D i f f A ct M a p ]
- 136 -
哈尔滨工业大学本科毕业设计(论文)
代码 B.6 FormatLayer.py
1 i mport numpy a s np
2 c l a s s F o rm at La y e r ( ) :
3 d e f i n i t ( s e l f , l a y e r , mapNum , mapRow , mapCol ) :
4 s e l f . mapNum = mapNum
5 s e l f . mapRow = mapRow
6 s e l f . mapCol = mapCol
7 s e l f . l a y e r = l a y e r
8
9 d e f f p r o p ( s e l f , d a t a ) :
10 re tu r n np . a r r a y ( d a t a ) . r e s h a p e ( ( 1 , 1 ) )
11
12 d e f s a v e P a r a m e t e r ( s e l f ) :
13 p r i n t f o r m a t l a y e r h as no p a r a m e t e r t o s a v e
14
15 d e f bp ro p ( s e l f , l o s s D i f f A c t , f e e d I n , o u t p u t ) :
16 l o s s D i f f A c t . s h ap e = s e l f . mapNum , s e l f . mapRow ,
17 s e l f . mapCol
18 re tu r n [ maps f o r maps i n l o s s D i f f A c t ]
- 137 -
代码 B.7 FullConnectLayer.py
1 from s c i p y i mport s t a t s
2 i mport numpy a s np
3
4 c l a s s F u l l C o n n e c t L a y e r ( ) :
5
6 d e f i n i t ( s e l f , l a y e r , visNum , hidNum ,
7 l o a d P a r a m e t e r = F a l s e ) :
8 s e l f . l a y e r = l a y e r
9 G a u s s i an = s t a t s . norm ( 0 , 0 . 0 1 )
10 i f l o a d P a r a m e t e r == F a l s e :
11 s e l f . w e i g h t = np . a r r a y ( G a u s s i a n . r v s (
12 ( hidNum , visNum ) ) )
13 s e l f . b i a s = np . z e r o s ( ( hidNum , 1 ) )
14 e l s e :
15 f p = open ( r w e i g h t + s t r ( s e l f . l a y e r ) , r b )
16 s e l f . w e i g h t = np . f r o m f i l e ( fp , d t y p e = np . d o u b l e )
17 . r e s h a p e ( hidNum , visNum )
18 f p . c l o s e ( )
19 f p = open ( r b i a s + s t r ( s e l f . l a y e r ) , r b )
20 s e l f . b i a s = np . f r o m f i l e ( fp , d t y p e = np . d o u b l e )
21 . r e s h a p e ( hidNum , 1 )
22 f p . c l o s e ( )
23 p r i n t f u l l c o n n e c t l a y e r , s e l f . l a y e r ,
24 p a r a m e t e r s had b e e n l o a d e d .
25 s e l f . l e a r n i n g R a t e = 0 . 0 0 1
26
27 d e f s a v e P a r a m e t e r ( s e l f ) :
28 f p = open ( r w e i g h t + s t r ( s e l f . l a y e r ) , wb )
29 f p . w r i t e ( s e l f . w e i g h t )
30 f p . c l o s e ( )
31 f p = open ( r b i a s + s t r ( s e l f . l a y e r ) , wb )
32 f p . w r i t e ( s e l f . b i a s )
- 138 -
哈尔滨工业大学本科毕业设计(论文)
33 f p . c l o s e ( )
34 p r i n t f u l l c o n n e c t l a y e r , s e l f . l a y e r ,
35 p a r a m e t e r s had be en s av e .
36
37 d e f f p r o p ( s e l f , d a t a ) :
38 n e t = np . d o t ( s e l f . w e ig h t , d a t a ) + s e l f . b i a s
39 f e a t u r e = 1 . 0 / ( 1 + np . exp ( n e t ) )
40 re tu r n f e a t u r e
41
42
43 d e f bp ro p ( s e l f , l o s s D i f f A c t , f e e d I n , o u t p u t ) :
44 a c t D i f f N e t = o u t p u t ( 1 o u t p u t )
45 s e n s = l o s s D i f f A c t a c t D i f f N e t
46 d e l t a W e i g h t = np . d o t ( s en s , f e e d I n . T )
47 s e l f . w e i g h t = s e l f . l e a r n i n g R a t e d e l t a W e i g h t
48 s e l f . b i a s = s e l f . l e a r n i n g R a t e s e n s
49 re tu r n np . d o t ( s e l f . w e i g h t . T , s e n s )
- 139 -
{% endraw %}